{-# LANGUAGE OverloadedStrings #-}

module Hydra.Sources.Tier1.CoreEncoding where

-- TODO: use standard Tier-1 imports
import Hydra.Sources.Tier0.All
import qualified Hydra.Dsl.Terms as Terms
import Hydra.Dsl.ShorthandTypes
import Hydra.Dsl.Base as Base
import qualified Hydra.Dsl.Core as Core
import qualified Hydra.Dsl.Types as Types
import Hydra.Sources.Libraries

import qualified Data.Map as M
import qualified Data.Set as S


coreEncodingModule :: Module
coreEncodingModule :: Module
coreEncodingModule = Namespace
-> [Element] -> [Module] -> [Module] -> Maybe [Char] -> Module
Module ([Char] -> Namespace
Namespace [Char]
"hydra/coreEncoding") [Element]
elements [] [Module]
tier0Modules (Maybe [Char] -> Module) -> Maybe [Char] -> Module
forall a b. (a -> b) -> a -> b
$
    [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char]
"Mapping of hydra/core constructs in a host language like Haskell or Java "
      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" to their native Hydra counterparts as terms. "
      [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" This includes an implementation of LambdaGraph's epsilon encoding (types to terms).")
  where
   elements :: [Element]
elements = [
     TElement (AnnotatedTerm -> Term) -> Element
forall a. TElement a -> Element
el TElement (AnnotatedTerm -> Term)
coreEncodeAnnotatedTermDef,
     TElement (AnnotatedType -> Term) -> Element
forall a. TElement a -> Element
el TElement (AnnotatedType -> Term)
coreEncodeAnnotatedTypeDef,
     TElement (Application -> Term) -> Element
forall a. TElement a -> Element
el TElement (Application -> Term)
coreEncodeApplicationDef,
     TElement (ApplicationType -> Term) -> Element
forall a. TElement a -> Element
el TElement (ApplicationType -> Term)
coreEncodeApplicationTypeDef,
     TElement (CaseStatement -> Term) -> Element
forall a. TElement a -> Element
el TElement (CaseStatement -> Term)
coreEncodeCaseStatementDef,
     TElement (Elimination -> Term) -> Element
forall a. TElement a -> Element
el TElement (Elimination -> Term)
coreEncodeEliminationDef,
     TElement (Field -> Term) -> Element
forall a. TElement a -> Element
el TElement (Field -> Term)
coreEncodeFieldDef,
     TElement (FieldType -> Term) -> Element
forall a. TElement a -> Element
el TElement (FieldType -> Term)
coreEncodeFieldTypeDef,
     TElement (FloatType -> Term) -> Element
forall a. TElement a -> Element
el TElement (FloatType -> Term)
coreEncodeFloatTypeDef,
     TElement (FloatValue -> Term) -> Element
forall a. TElement a -> Element
el TElement (FloatValue -> Term)
coreEncodeFloatValueDef,
     TElement (Function -> Term) -> Element
forall a. TElement a -> Element
el TElement (Function -> Term)
coreEncodeFunctionDef,
     TElement (FunctionType -> Term) -> Element
forall a. TElement a -> Element
el TElement (FunctionType -> Term)
coreEncodeFunctionTypeDef,
     TElement (Injection -> Term) -> Element
forall a. TElement a -> Element
el TElement (Injection -> Term)
coreEncodeInjectionDef,
     TElement (IntegerType -> Term) -> Element
forall a. TElement a -> Element
el TElement (IntegerType -> Term)
coreEncodeIntegerTypeDef,
     TElement (IntegerValue -> Term) -> Element
forall a. TElement a -> Element
el TElement (IntegerValue -> Term)
coreEncodeIntegerValueDef,
     TElement (Lambda -> Term) -> Element
forall a. TElement a -> Element
el TElement (Lambda -> Term)
coreEncodeLambdaDef,
     TElement (LambdaType -> Term) -> Element
forall a. TElement a -> Element
el TElement (LambdaType -> Term)
coreEncodeLambdaTypeDef,
     TElement (Let -> Term) -> Element
forall a. TElement a -> Element
el TElement (Let -> Term)
coreEncodeLetDef,
     TElement (LetBinding -> Term) -> Element
forall a. TElement a -> Element
el TElement (LetBinding -> Term)
coreEncodeLetBindingDef,
     TElement (Literal -> Term) -> Element
forall a. TElement a -> Element
el TElement (Literal -> Term)
coreEncodeLiteralDef,
     TElement (LiteralType -> Term) -> Element
forall a. TElement a -> Element
el TElement (LiteralType -> Term)
coreEncodeLiteralTypeDef,
     TElement (MapType -> Term) -> Element
forall a. TElement a -> Element
el TElement (MapType -> Term)
coreEncodeMapTypeDef,
     TElement (Name -> Term) -> Element
forall a. TElement a -> Element
el TElement (Name -> Term)
coreEncodeNameDef,
     TElement (OptionalCases -> Term) -> Element
forall a. TElement a -> Element
el TElement (OptionalCases -> Term)
coreEncodeOptionalCasesDef,
     TElement (Projection -> Term) -> Element
forall a. TElement a -> Element
el TElement (Projection -> Term)
coreEncodeProjectionDef,
     TElement (Record -> Term) -> Element
forall a. TElement a -> Element
el TElement (Record -> Term)
coreEncodeRecordDef,
     TElement (RowType -> Term) -> Element
forall a. TElement a -> Element
el TElement (RowType -> Term)
coreEncodeRowTypeDef,
     TElement (Sum -> Term) -> Element
forall a. TElement a -> Element
el TElement (Sum -> Term)
coreEncodeSumDef,
     TElement (Term -> Term) -> Element
forall a. TElement a -> Element
el TElement (Term -> Term)
coreEncodeTermDef,
     TElement (TupleProjection -> Term) -> Element
forall a. TElement a -> Element
el TElement (TupleProjection -> Term)
coreEncodeTupleProjectionDef,
     TElement (Type -> Term) -> Element
forall a. TElement a -> Element
el TElement (Type -> Term)
coreEncodeTypeDef,
     TElement (TypeAbstraction -> Term) -> Element
forall a. TElement a -> Element
el TElement (TypeAbstraction -> Term)
coreEncodeTypeAbstractionDef,
     TElement (TypeScheme -> Term) -> Element
forall a. TElement a -> Element
el TElement (TypeScheme -> Term)
coreEncodeTypeSchemeDef,
     TElement (TypedTerm -> Term) -> Element
forall a. TElement a -> Element
el TElement (TypedTerm -> Term)
coreEncodeTypedTermDef,
     TElement (WrappedTerm -> Term) -> Element
forall a. TElement a -> Element
el TElement (WrappedTerm -> Term)
coreEncodeWrappedTermDef,
     TElement (WrappedType -> Term) -> Element
forall a. TElement a -> Element
el TElement (WrappedType -> Term)
coreEncodeWrappedTypeDef]

coreEncodingDefinition :: String -> Type -> TTerm x -> TElement x
coreEncodingDefinition :: forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
label Type
dom TTerm x
datum = Module -> [Char] -> TTerm x -> TElement x
forall a. Module -> [Char] -> TTerm a -> TElement a
definitionInModule Module
coreEncodingModule ([Char]
"coreEncode" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
label) (TTerm x -> TElement x) -> TTerm x -> TElement x
forall a b. (a -> b) -> a -> b
$
  Type -> Type -> TTerm x -> TTerm x
forall a. Type -> Type -> TTerm a -> TTerm a
function Type
dom Type
termT TTerm x
datum

encodedBinary :: TTerm String -> TTerm Term
encodedBinary :: TTerm [Char] -> TTerm Term
encodedBinary = TTerm Literal -> TTerm Term
encodedLiteral (TTerm Literal -> TTerm Term)
-> (TTerm [Char] -> TTerm Literal) -> TTerm [Char] -> TTerm Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TTerm [Char] -> TTerm Literal
Core.literalBinary

encodedBoolean :: TTerm Bool -> TTerm Term
encodedBoolean :: TTerm Bool -> TTerm Term
encodedBoolean = TTerm Literal -> TTerm Term
encodedLiteral (TTerm Literal -> TTerm Term)
-> (TTerm Bool -> TTerm Literal) -> TTerm Bool -> TTerm Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TTerm Bool -> TTerm Literal
Core.literalBoolean

encodedCase :: Name -> Name -> TTerm (a -> Term) -> Field
encodedCase :: forall a. Name -> Name -> TTerm (a -> Term) -> Field
encodedCase Name
tname Name
fname TTerm (a -> Term)
enc = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> TTerm Term -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
tname Name
fname (TTerm (a -> Term)
enc TTerm (a -> Term) -> TTerm a -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm a
forall a. [Char] -> TTerm a
var [Char]
"v")

encodedField :: Name -> TTerm Term -> TTerm Term
encodedField :: Name -> TTerm Term -> TTerm Term
encodedField Name
fname TTerm Term
term = TTerm Name -> TTerm Term -> TTerm Term
encodedFieldRaw (Name -> TTerm Name
encodedName Name
fname) TTerm Term
term

encodedFieldRaw :: TTerm Name -> TTerm Term -> TTerm Term
encodedFieldRaw :: TTerm Name -> TTerm Term -> TTerm Term
encodedFieldRaw (TTerm Term
fname) (TTerm Term
term) = Term -> TTerm Term
forall a. Term -> TTerm a
TTerm (Term -> TTerm Term) -> Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> Term
Terms.record Name
_Field [
  Name -> Term -> Field
Field Name
_Field_name Term
fname,
  Name -> Term -> Field
Field Name
_Field_term Term
term]

encodedFloatValue :: TTerm FloatValue -> TTerm Term
encodedFloatValue :: TTerm FloatValue -> TTerm Term
encodedFloatValue = TTerm Literal -> TTerm Term
encodedLiteral (TTerm Literal -> TTerm Term)
-> (TTerm FloatValue -> TTerm Literal)
-> TTerm FloatValue
-> TTerm Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TTerm FloatValue -> TTerm Literal
Core.literalFloat

encodedInjection :: Name -> Name -> TTerm Term -> TTerm Term
encodedInjection :: Name -> Name -> TTerm Term -> TTerm Term
encodedInjection Name
tname Name
fname TTerm Term
term = Term -> TTerm Term
forall a. Term -> TTerm a
TTerm (Term -> TTerm Term) -> Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> Term
Terms.record Name
_Injection [
  Name -> TTerm Name -> Field
forall a. Name -> TTerm a -> Field
field Name
_Injection_typeName (TTerm Name -> Field) -> TTerm Name -> Field
forall a b. (a -> b) -> a -> b
$ Name -> TTerm Name
encodedName Name
tname,
  Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Injection_field (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ Name -> TTerm Term -> TTerm Term
encodedField Name
fname TTerm Term
term]

encodedInt32 :: TTerm Int -> TTerm Term
encodedInt32 :: TTerm Int -> TTerm Term
encodedInt32 TTerm Int
v = TTerm IntegerValue -> TTerm Term
encodedIntegerValue (TTerm IntegerValue -> TTerm Term)
-> TTerm IntegerValue -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Int -> TTerm IntegerValue
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_IntegerValue Name
_IntegerValue_int32 TTerm Int
v

encodedIntegerValue :: TTerm IntegerValue -> TTerm Term
encodedIntegerValue :: TTerm IntegerValue -> TTerm Term
encodedIntegerValue = TTerm Literal -> TTerm Term
encodedLiteral (TTerm Literal -> TTerm Term)
-> (TTerm IntegerValue -> TTerm Literal)
-> TTerm IntegerValue
-> TTerm Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TTerm IntegerValue -> TTerm Literal
Core.literalInteger

encodedList :: TTerm [a] -> TTerm Term
encodedList :: forall a. TTerm [a] -> TTerm Term
encodedList = Name -> Name -> TTerm [a] -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_list

encodedLiteral :: TTerm Literal -> TTerm Term
encodedLiteral :: TTerm Literal -> TTerm Term
encodedLiteral = Name -> Name -> TTerm Literal -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_literal

encodedMap :: TTerm (M.Map k v) -> TTerm Term
encodedMap :: forall k v. TTerm (Map k v) -> TTerm Term
encodedMap = Name -> Name -> TTerm (Map k v) -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_map

encodedName :: Name -> TTerm Name
encodedName :: Name -> TTerm Name
encodedName = Name -> TTerm [Char] -> TTerm Name
forall a b. Name -> TTerm a -> TTerm b
wrap Name
_Name (TTerm [Char] -> TTerm Name)
-> (Name -> TTerm [Char]) -> Name -> TTerm Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> TTerm [Char]
string ([Char] -> TTerm [Char])
-> (Name -> [Char]) -> Name -> TTerm [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> [Char]
unName

encodedWrappedTerm :: Name -> TTerm Term -> TTerm Term
encodedWrappedTerm :: Name -> TTerm Term -> TTerm Term
encodedWrappedTerm Name
name = TTerm Name -> TTerm Term -> TTerm Term
encodedWrappedTermRaw (Name -> TTerm Name
encodedName Name
name)

encodedWrappedTermRaw :: TTerm Name -> TTerm Term -> TTerm Term
encodedWrappedTermRaw :: TTerm Name -> TTerm Term -> TTerm Term
encodedWrappedTermRaw (TTerm Term
name) (TTerm Term
term) = Term -> TTerm Term
forall a. Term -> TTerm a
TTerm (Term -> TTerm Term) -> Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Term -> Term
Terms.variant Name
_Term Name
_Term_wrap (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> Term
Terms.record Name
_WrappedTerm [
  Name -> Term -> Field
Field Name
_WrappedTerm_typeName Term
name,
  Name -> Term -> Field
Field Name
_WrappedTerm_object Term
term]

encodedOptional :: TTerm (Maybe a) -> TTerm Term
encodedOptional :: forall a. TTerm (Maybe a) -> TTerm Term
encodedOptional = Name -> Name -> TTerm (Maybe a) -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_optional

encodedRecord :: Name -> [Field] -> TTerm Term
encodedRecord :: Name -> [Field] -> TTerm Term
encodedRecord Name
tname [Field]
fields = Term -> TTerm Term
forall a. Term -> TTerm a
TTerm (Term -> TTerm Term) -> Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Term -> Term
Terms.variant Name
_Term Name
_Term_record (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> Term
Terms.record Name
_Record [
    Name -> TTerm Name -> Field
forall a. Name -> TTerm a -> Field
field Name
_Record_typeName (TTerm Name -> Field) -> TTerm Name -> Field
forall a b. (a -> b) -> a -> b
$ Name -> TTerm Name
encodedName Name
tname,
    Name -> TTerm [Term] -> Field
forall a. Name -> TTerm a -> Field
field Name
_Record_fields (TTerm [Term] -> Field) -> TTerm [Term] -> Field
forall a b. (a -> b) -> a -> b
$ [TTerm Term] -> TTerm [Term]
forall a. [TTerm a] -> TTerm [a]
list (Field -> TTerm Term
encField (Field -> TTerm Term) -> [Field] -> [TTerm Term]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Field]
fields)]
  where
    encField :: Field -> TTerm Term
encField (Field Name
fname Term
term) = Name -> TTerm Term -> TTerm Term
encodedField Name
fname (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Term -> TTerm Term
forall a. Term -> TTerm a
TTerm Term
term

encodedSet :: TTerm (S.Set a) -> TTerm Term
encodedSet :: forall a. TTerm (Set a) -> TTerm Term
encodedSet = Name -> Name -> TTerm (Set a) -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_set

encodedString :: TTerm String -> TTerm Term
encodedString :: TTerm [Char] -> TTerm Term
encodedString = TTerm Literal -> TTerm Term
encodedLiteral (TTerm Literal -> TTerm Term)
-> (TTerm [Char] -> TTerm Literal) -> TTerm [Char] -> TTerm Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name -> TTerm [Char] -> TTerm Literal
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Literal Name
_Literal_string

encodedUnion :: TTerm Term -> TTerm Term
encodedUnion :: TTerm Term -> TTerm Term
encodedUnion = Name -> Name -> TTerm Term -> TTerm Term
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_union

encodedVariant :: Name -> Name -> TTerm Term -> TTerm Term
encodedVariant :: Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
tname Name
fname TTerm Term
term = TTerm Term -> TTerm Term
encodedUnion (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedInjection Name
tname Name
fname TTerm Term
term

coreEncodeAnnotatedTermDef :: TElement (AnnotatedTerm -> Term)
coreEncodeAnnotatedTermDef :: TElement (AnnotatedTerm -> Term)
coreEncodeAnnotatedTermDef = [Char]
-> Type
-> TTerm (AnnotatedTerm -> Term)
-> TElement (AnnotatedTerm -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"AnnotatedTerm" Type
annotatedTermT (TTerm (AnnotatedTerm -> Term) -> TElement (AnnotatedTerm -> Term))
-> TTerm (AnnotatedTerm -> Term)
-> TElement (AnnotatedTerm -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Any -> TTerm (AnnotatedTerm -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"a" (TTerm Any -> TTerm (AnnotatedTerm -> Term))
-> TTerm Any -> TTerm (AnnotatedTerm -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any -> TTerm Any
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_annotated (TTerm Any -> TTerm Any) -> TTerm Any -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Any
forall a. Name -> [Field] -> TTerm a
record Name
_AnnotatedTerm [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_subject (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (AnnotatedTerm -> Term)
Core.annotatedTermSubject TTerm (AnnotatedTerm -> Term) -> TTerm AnnotatedTerm -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedTerm
forall a. [Char] -> TTerm a
var [Char]
"a"),
    Name -> TTerm (Map [Char] Term) -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_annotation (TTerm (Map [Char] Term) -> Field)
-> TTerm (Map [Char] Term) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (AnnotatedTerm -> Map [Char] Term)
Core.annotatedTermAnnotation TTerm (AnnotatedTerm -> Map [Char] Term)
-> TTerm AnnotatedTerm -> TTerm (Map [Char] Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedTerm
forall a. [Char] -> TTerm a
var [Char]
"a"]

coreEncodeAnnotatedTypeDef :: TElement (AnnotatedType -> Term)
coreEncodeAnnotatedTypeDef :: TElement (AnnotatedType -> Term)
coreEncodeAnnotatedTypeDef = [Char]
-> Type
-> TTerm (AnnotatedType -> Term)
-> TElement (AnnotatedType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"AnnotatedType" Type
annotatedTypeT (TTerm (AnnotatedType -> Term) -> TElement (AnnotatedType -> Term))
-> TTerm (AnnotatedType -> Term)
-> TElement (AnnotatedType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Any -> TTerm (AnnotatedType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"at" (TTerm Any -> TTerm (AnnotatedType -> Term))
-> TTerm Any -> TTerm (AnnotatedType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any -> TTerm Any
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_annotated (TTerm Any -> TTerm Any) -> TTerm Any -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Any
forall a. Name -> [Field] -> TTerm a
record Name
_AnnotatedTerm [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_subject (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (AnnotatedType -> Type)
Core.annotatedTypeSubject TTerm (AnnotatedType -> Type) -> TTerm AnnotatedType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedType
forall a. [Char] -> TTerm a
var [Char]
"at"),
    Name -> TTerm (Map [Char] Term) -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_annotation (TTerm (Map [Char] Term) -> Field)
-> TTerm (Map [Char] Term) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (AnnotatedType -> Map [Char] Term)
Core.annotatedTypeAnnotation TTerm (AnnotatedType -> Map [Char] Term)
-> TTerm AnnotatedType -> TTerm (Map [Char] Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedType
forall a. [Char] -> TTerm a
var [Char]
"at"]

coreEncodeApplicationDef :: TElement (Application -> Term)
coreEncodeApplicationDef :: TElement (Application -> Term)
coreEncodeApplicationDef = [Char]
-> Type
-> TTerm (Application -> Term)
-> TElement (Application -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Application" Type
applicationT (TTerm (Application -> Term) -> TElement (Application -> Term))
-> TTerm (Application -> Term) -> TElement (Application -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Application -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"app" (TTerm Term -> TTerm (Application -> Term))
-> TTerm Term -> TTerm (Application -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Application [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Application_function (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Application -> Term)
Core.applicationFunction TTerm (Application -> Term) -> TTerm Application -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Application
forall a. [Char] -> TTerm a
var [Char]
"app"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Application_argument (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Application -> Term)
Core.applicationArgument TTerm (Application -> Term) -> TTerm Application -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Application
forall a. [Char] -> TTerm a
var [Char]
"app")]

coreEncodeApplicationTypeDef :: TElement (ApplicationType -> Term)
coreEncodeApplicationTypeDef :: TElement (ApplicationType -> Term)
coreEncodeApplicationTypeDef = [Char]
-> Type
-> TTerm (ApplicationType -> Term)
-> TElement (ApplicationType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"ApplicationType" Type
applicationTypeT (TTerm (ApplicationType -> Term)
 -> TElement (ApplicationType -> Term))
-> TTerm (ApplicationType -> Term)
-> TElement (ApplicationType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (ApplicationType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"at" (TTerm Term -> TTerm (ApplicationType -> Term))
-> TTerm Term -> TTerm (ApplicationType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_ApplicationType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_ApplicationType_function (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (ApplicationType -> Type)
Core.applicationTypeFunction TTerm (ApplicationType -> Type)
-> TTerm ApplicationType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm ApplicationType
forall a. [Char] -> TTerm a
var [Char]
"at"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_ApplicationType_argument (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (ApplicationType -> Type)
Core.applicationTypeArgument TTerm (ApplicationType -> Type)
-> TTerm ApplicationType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm ApplicationType
forall a. [Char] -> TTerm a
var [Char]
"at")]

coreEncodeCaseStatementDef :: TElement (CaseStatement -> Term)
coreEncodeCaseStatementDef :: TElement (CaseStatement -> Term)
coreEncodeCaseStatementDef = [Char]
-> Type
-> TTerm (CaseStatement -> Term)
-> TElement (CaseStatement -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"CaseStatement" Type
caseStatementT (TTerm (CaseStatement -> Term) -> TElement (CaseStatement -> Term))
-> TTerm (CaseStatement -> Term)
-> TElement (CaseStatement -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (CaseStatement -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"cs" (TTerm Term -> TTerm (CaseStatement -> Term))
-> TTerm Term -> TTerm (CaseStatement -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_CaseStatement [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_CaseStatement_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (CaseStatement -> Name)
Core.caseStatementTypeName TTerm (CaseStatement -> Name) -> TTerm CaseStatement -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm CaseStatement
forall a. [Char] -> TTerm a
var [Char]
"cs"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_CaseStatement_default (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (Maybe Any) -> TTerm Term
forall a. TTerm (Maybe a) -> TTerm Term
encodedOptional
      (Name -> TTerm ((Term -> Term) -> Maybe Term -> Maybe Any)
forall a. Name -> TTerm a
primitive Name
_optionals_map TTerm ((Term -> Term) -> Maybe Term -> Maybe Any)
-> TTerm (Term -> Term) -> TTerm (Maybe Term -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Maybe Term -> Maybe Any)
-> TTerm (Maybe Term) -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (CaseStatement -> Maybe Term)
Core.caseStatementDefault TTerm (CaseStatement -> Maybe Term)
-> TTerm CaseStatement -> TTerm (Maybe Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm CaseStatement
forall a. [Char] -> TTerm a
var [Char]
"cs")),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_CaseStatement_cases (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList
      (Name -> TTerm ((Field -> Term) -> [Field] -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Field -> Term) -> [Field] -> [Any])
-> TTerm (Field -> Term) -> TTerm ([Field] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Field -> Term) -> TTerm (Field -> Term)
forall a. TElement a -> TTerm a
ref TElement (Field -> Term)
coreEncodeFieldDef TTerm ([Field] -> [Any]) -> TTerm [Field] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (CaseStatement -> [Field])
Core.caseStatementCases TTerm (CaseStatement -> [Field])
-> TTerm CaseStatement -> TTerm [Field]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm CaseStatement
forall a. [Char] -> TTerm a
var [Char]
"cs"))]

coreEncodeEliminationDef :: TElement (Elimination -> Term)
coreEncodeEliminationDef :: TElement (Elimination -> Term)
coreEncodeEliminationDef = [Char]
-> Type
-> TTerm (Elimination -> Term)
-> TElement (Elimination -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Elimination" Type
eliminationT (TTerm (Elimination -> Term) -> TElement (Elimination -> Term))
-> TTerm (Elimination -> Term) -> TElement (Elimination -> Term)
forall a b. (a -> b) -> a -> b
$
    Name
-> Maybe (TTerm Term) -> [Field] -> TTerm (Elimination -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_Elimination Maybe (TTerm Term)
forall a. Maybe a
Nothing [
      Name -> TElement (Term -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_list TElement (Term -> Term)
coreEncodeTermDef,
      Name -> TElement (OptionalCases -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_optional TElement (OptionalCases -> Term)
coreEncodeOptionalCasesDef,
      Name -> TElement (TupleProjection -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_product TElement (TupleProjection -> Term)
coreEncodeTupleProjectionDef,
      Name -> TElement (Projection -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_record TElement (Projection -> Term)
coreEncodeProjectionDef,
      Name -> TElement (CaseStatement -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_union TElement (CaseStatement -> Term)
coreEncodeCaseStatementDef,
      Name -> TElement (Name -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Elimination_wrap TElement (Name -> Term)
coreEncodeNameDef]
  where
    ecase :: Name -> TElement (a -> Term) -> Field
ecase Name
fname TElement (a -> Term)
funname = Name -> Name -> TTerm (a -> Term) -> Field
forall a. Name -> Name -> TTerm (a -> Term) -> Field
encodedCase Name
_Elimination Name
fname (TElement (a -> Term) -> TTerm (a -> Term)
forall a. TElement a -> TTerm a
ref TElement (a -> Term)
funname)

coreEncodeFieldDef :: TElement (Field -> Term)
coreEncodeFieldDef :: TElement (Field -> Term)
coreEncodeFieldDef = [Char] -> Type -> TTerm (Field -> Term) -> TElement (Field -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Field" Type
fieldT (TTerm (Field -> Term) -> TElement (Field -> Term))
-> TTerm (Field -> Term) -> TElement (Field -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Field -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"f" (TTerm Term -> TTerm (Field -> Term))
-> TTerm Term -> TTerm (Field -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Field [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Field_name (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ Name -> TTerm Term -> TTerm Term
encodedWrappedTerm Name
_Name (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm [Char] -> TTerm Term
encodedString (TTerm [Char] -> TTerm Term) -> TTerm [Char] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ (Name -> TTerm (Name -> [Char])
forall a b. Name -> TTerm (a -> b)
unwrap Name
_Name TTerm (Name -> [Char]) -> TTerm Name -> TTerm [Char]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Field -> Name)
Core.fieldName TTerm (Field -> Name) -> TTerm Field -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Field
forall a. [Char] -> TTerm a
var [Char]
"f")),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Field_term (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Field -> Term)
Core.fieldTerm TTerm (Field -> Term) -> TTerm Field -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Field
forall a. [Char] -> TTerm a
var [Char]
"f")]

coreEncodeFieldTypeDef :: TElement (FieldType -> Term)
coreEncodeFieldTypeDef :: TElement (FieldType -> Term)
coreEncodeFieldTypeDef = [Char]
-> Type
-> TTerm (FieldType -> Term)
-> TElement (FieldType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"FieldType" Type
fieldTypeT (TTerm (FieldType -> Term) -> TElement (FieldType -> Term))
-> TTerm (FieldType -> Term) -> TElement (FieldType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (FieldType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"ft" (TTerm Term -> TTerm (FieldType -> Term))
-> TTerm Term -> TTerm (FieldType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_FieldType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_FieldType_name (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (FieldType -> Name)
Core.fieldTypeName TTerm (FieldType -> Name) -> TTerm FieldType -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm FieldType
forall a. [Char] -> TTerm a
var [Char]
"ft"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_FieldType_type (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (FieldType -> Type)
Core.fieldTypeType TTerm (FieldType -> Type) -> TTerm FieldType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm FieldType
forall a. [Char] -> TTerm a
var [Char]
"ft")]

coreEncodeFloatTypeDef :: TElement (FloatType -> Term)
coreEncodeFloatTypeDef :: TElement (FloatType -> Term)
coreEncodeFloatTypeDef = [Char]
-> Type
-> TTerm (FloatType -> Term)
-> TElement (FloatType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"FloatType" Type
floatTypeT (TTerm (FloatType -> Term) -> TElement (FloatType -> Term))
-> TTerm (FloatType -> Term) -> TElement (FloatType -> Term)
forall a b. (a -> b) -> a -> b
$
    Name -> Maybe (TTerm Term) -> [Field] -> TTerm (FloatType -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_FloatType Maybe (TTerm Term)
forall a. Maybe a
Nothing (Name -> Field
cs (Name -> Field) -> [Name] -> [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
      Name
_FloatType_bigfloat,
      Name
_FloatType_float32,
      Name
_FloatType_float64])
  where
    cs :: Name -> Field
cs Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Any -> TTerm (Any -> Any)
forall a b. TTerm a -> TTerm (b -> a)
constant (TTerm Any -> TTerm (Any -> Any))
-> TTerm Any -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Term -> TTerm Any
forall a. Term -> TTerm a
TTerm (Term -> TTerm Any) -> Term -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Term -> Term
coreEncodeTerm (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ TTerm Any -> Term
forall a. TTerm a -> Term
unTTerm (TTerm Any -> Term) -> TTerm Any -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any
forall a. Name -> Name -> TTerm a
unitVariant Name
_FloatType Name
fname

coreEncodeFloatValueDef :: TElement (FloatValue -> Term)
coreEncodeFloatValueDef :: TElement (FloatValue -> Term)
coreEncodeFloatValueDef = [Char]
-> Type
-> TTerm (FloatValue -> Term)
-> TElement (FloatValue -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"FloatValue" Type
floatValueT (TTerm (FloatValue -> Term) -> TElement (FloatValue -> Term))
-> TTerm (FloatValue -> Term) -> TElement (FloatValue -> Term)
forall a b. (a -> b) -> a -> b
$
  Name -> Maybe (TTerm Term) -> [Field] -> TTerm (FloatValue -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_FloatValue Maybe (TTerm Term)
forall a. Maybe a
Nothing (Name -> Field
varField (Name -> Field) -> [Name] -> [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
    Name
_FloatValue_bigfloat,
    Name
_FloatValue_float32,
    Name
_FloatValue_float64])
  where
    varField :: Name -> Field
varField Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> TTerm Term -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_FloatValue Name
fname (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm FloatValue -> TTerm Term
encodedFloatValue (TTerm FloatValue -> TTerm Term) -> TTerm FloatValue -> TTerm Term
forall a b. (a -> b) -> a -> b
$
      Name -> Name -> TTerm Any -> TTerm FloatValue
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_FloatValue Name
fname (TTerm Any -> TTerm FloatValue) -> TTerm Any -> TTerm FloatValue
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v"

coreEncodeFunctionDef :: TElement (Function -> Term)
coreEncodeFunctionDef :: TElement (Function -> Term)
coreEncodeFunctionDef = [Char]
-> Type -> TTerm (Function -> Term) -> TElement (Function -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Function" Type
functionT (TTerm (Function -> Term) -> TElement (Function -> Term))
-> TTerm (Function -> Term) -> TElement (Function -> Term)
forall a b. (a -> b) -> a -> b
$
    Name -> Maybe (TTerm Term) -> [Field] -> TTerm (Function -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_Function Maybe (TTerm Term)
forall a. Maybe a
Nothing [
      Name -> TElement (Elimination -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Function_elimination TElement (Elimination -> Term)
coreEncodeEliminationDef,
      Name -> TElement (Lambda -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Function_lambda TElement (Lambda -> Term)
coreEncodeLambdaDef,
      Name -> TElement (Name -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
ecase Name
_Function_primitive TElement (Name -> Term)
coreEncodeNameDef]
  where
    ecase :: Name -> TElement (a -> Term) -> Field
ecase Name
fname TElement (a -> Term)
funname = Name -> Name -> TTerm (a -> Term) -> Field
forall a. Name -> Name -> TTerm (a -> Term) -> Field
encodedCase Name
_Function Name
fname (TElement (a -> Term) -> TTerm (a -> Term)
forall a. TElement a -> TTerm a
ref TElement (a -> Term)
funname)

coreEncodeFunctionTypeDef :: TElement (FunctionType -> Term)
coreEncodeFunctionTypeDef :: TElement (FunctionType -> Term)
coreEncodeFunctionTypeDef = [Char]
-> Type
-> TTerm (FunctionType -> Term)
-> TElement (FunctionType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"FunctionType" Type
functionTypeT (TTerm (FunctionType -> Term) -> TElement (FunctionType -> Term))
-> TTerm (FunctionType -> Term) -> TElement (FunctionType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (FunctionType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"ft" (TTerm Term -> TTerm (FunctionType -> Term))
-> TTerm Term -> TTerm (FunctionType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_FunctionType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_FunctionType_domain (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (FunctionType -> Type)
Core.functionTypeDomain TTerm (FunctionType -> Type) -> TTerm FunctionType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm FunctionType
forall a. [Char] -> TTerm a
var [Char]
"ft"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_FunctionType_codomain (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (FunctionType -> Type)
Core.functionTypeCodomain TTerm (FunctionType -> Type) -> TTerm FunctionType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm FunctionType
forall a. [Char] -> TTerm a
var [Char]
"ft")]

coreEncodeInjectionDef :: TElement (Injection -> Term)
coreEncodeInjectionDef :: TElement (Injection -> Term)
coreEncodeInjectionDef = [Char]
-> Type
-> TTerm (Injection -> Term)
-> TElement (Injection -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Injection" Type
injectionT (TTerm (Injection -> Term) -> TElement (Injection -> Term))
-> TTerm (Injection -> Term) -> TElement (Injection -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Injection -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"i" (TTerm Term -> TTerm (Injection -> Term))
-> TTerm Term -> TTerm (Injection -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Injection [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Injection_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Injection -> Name)
Core.injectionTypeName TTerm (Injection -> Name) -> TTerm Injection -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Injection
forall a. [Char] -> TTerm a
var [Char]
"i"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Injection_field (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Field -> Term) -> TTerm (Field -> Term)
forall a. TElement a -> TTerm a
ref TElement (Field -> Term)
coreEncodeFieldDef TTerm (Field -> Term) -> TTerm Field -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Injection -> Field)
Core.injectionField TTerm (Injection -> Field) -> TTerm Injection -> TTerm Field
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Injection
forall a. [Char] -> TTerm a
var [Char]
"i")]

coreEncodeIntegerTypeDef :: TElement (IntegerType -> Term)
coreEncodeIntegerTypeDef :: TElement (IntegerType -> Term)
coreEncodeIntegerTypeDef = [Char]
-> Type
-> TTerm (IntegerType -> Term)
-> TElement (IntegerType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"IntegerType" Type
integerTypeT (TTerm (IntegerType -> Term) -> TElement (IntegerType -> Term))
-> TTerm (IntegerType -> Term) -> TElement (IntegerType -> Term)
forall a b. (a -> b) -> a -> b
$
    Name
-> Maybe (TTerm Term) -> [Field] -> TTerm (IntegerType -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_IntegerType Maybe (TTerm Term)
forall a. Maybe a
Nothing (Name -> Field
cs (Name -> Field) -> [Name] -> [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
      Name
_IntegerType_bigint,
      Name
_IntegerType_int8,
      Name
_IntegerType_int16,
      Name
_IntegerType_int32,
      Name
_IntegerType_int64,
      Name
_IntegerType_uint8,
      Name
_IntegerType_uint16,
      Name
_IntegerType_uint32,
      Name
_IntegerType_uint64])
  where
    cs :: Name -> Field
cs Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Any -> TTerm (Any -> Any)
forall a b. TTerm a -> TTerm (b -> a)
constant (TTerm Any -> TTerm (Any -> Any))
-> TTerm Any -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Term -> TTerm Any
forall a. Term -> TTerm a
TTerm (Term -> TTerm Any) -> Term -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Term -> Term
coreEncodeTerm (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ TTerm Any -> Term
forall a. TTerm a -> Term
unTTerm (TTerm Any -> Term) -> TTerm Any -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any
forall a. Name -> Name -> TTerm a
unitVariant Name
_IntegerType Name
fname

coreEncodeIntegerValueDef :: TElement (IntegerValue -> Term)
coreEncodeIntegerValueDef :: TElement (IntegerValue -> Term)
coreEncodeIntegerValueDef = [Char]
-> Type
-> TTerm (IntegerValue -> Term)
-> TElement (IntegerValue -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"IntegerValue" Type
integerValueT (TTerm (IntegerValue -> Term) -> TElement (IntegerValue -> Term))
-> TTerm (IntegerValue -> Term) -> TElement (IntegerValue -> Term)
forall a b. (a -> b) -> a -> b
$
  Name
-> Maybe (TTerm Term) -> [Field] -> TTerm (IntegerValue -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_IntegerValue Maybe (TTerm Term)
forall a. Maybe a
Nothing (Name -> Field
varField (Name -> Field) -> [Name] -> [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [
    Name
_IntegerValue_bigint,
    Name
_IntegerValue_int8,
    Name
_IntegerValue_int16,
    Name
_IntegerValue_int32,
    Name
_IntegerValue_int64,
    Name
_IntegerValue_uint8,
    Name
_IntegerValue_uint16,
    Name
_IntegerValue_uint32,
    Name
_IntegerValue_uint64])
  where
    varField :: Name -> Field
varField Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> TTerm Term -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_IntegerValue Name
fname (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm IntegerValue -> TTerm Term
encodedIntegerValue (TTerm IntegerValue -> TTerm Term)
-> TTerm IntegerValue -> TTerm Term
forall a b. (a -> b) -> a -> b
$
      Name -> Name -> TTerm Any -> TTerm IntegerValue
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_IntegerValue Name
fname (TTerm Any -> TTerm IntegerValue)
-> TTerm Any -> TTerm IntegerValue
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v"

coreEncodeLambdaDef :: TElement (Lambda -> Term)
coreEncodeLambdaDef :: TElement (Lambda -> Term)
coreEncodeLambdaDef = [Char]
-> Type -> TTerm (Lambda -> Term) -> TElement (Lambda -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Lambda" Type
lambdaT (TTerm (Lambda -> Term) -> TElement (Lambda -> Term))
-> TTerm (Lambda -> Term) -> TElement (Lambda -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Lambda -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"l" (TTerm Term -> TTerm (Lambda -> Term))
-> TTerm Term -> TTerm (Lambda -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Lambda [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Lambda_parameter (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Lambda -> Name)
Core.lambdaParameter TTerm (Lambda -> Name) -> TTerm Lambda -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Lambda
forall a. [Char] -> TTerm a
var [Char]
"l"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Lambda_domain (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (Maybe Any) -> TTerm Term
forall a. TTerm (Maybe a) -> TTerm Term
encodedOptional (TTerm (Maybe Any) -> TTerm Term)
-> TTerm (Maybe Any) -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm ((Type -> Term) -> Maybe Type -> Maybe Any)
forall a. Name -> TTerm a
primitive Name
_optionals_map TTerm ((Type -> Term) -> Maybe Type -> Maybe Any)
-> TTerm (Type -> Term) -> TTerm (Maybe Type -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Maybe Type -> Maybe Any)
-> TTerm (Maybe Type) -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Lambda -> Maybe Type)
Core.lambdaDomain TTerm (Lambda -> Maybe Type) -> TTerm Lambda -> TTerm (Maybe Type)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Lambda
forall a. [Char] -> TTerm a
var [Char]
"l"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Lambda_body (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Lambda -> Term)
Core.lambdaBody TTerm (Lambda -> Term) -> TTerm Lambda -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Lambda
forall a. [Char] -> TTerm a
var [Char]
"l")]

coreEncodeLambdaTypeDef :: TElement (LambdaType -> Term)
coreEncodeLambdaTypeDef :: TElement (LambdaType -> Term)
coreEncodeLambdaTypeDef = [Char]
-> Type
-> TTerm (LambdaType -> Term)
-> TElement (LambdaType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"LambdaType" Type
lambdaTypeT (TTerm (LambdaType -> Term) -> TElement (LambdaType -> Term))
-> TTerm (LambdaType -> Term) -> TElement (LambdaType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (LambdaType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"lt" (TTerm Term -> TTerm (LambdaType -> Term))
-> TTerm Term -> TTerm (LambdaType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_LambdaType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_LambdaType_parameter (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LambdaType -> Name)
Core.lambdaTypeParameter TTerm (LambdaType -> Name) -> TTerm LambdaType -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm LambdaType
forall a. [Char] -> TTerm a
var [Char]
"lt"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_LambdaType_body (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LambdaType -> Type)
Core.lambdaTypeBody TTerm (LambdaType -> Type) -> TTerm LambdaType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm LambdaType
forall a. [Char] -> TTerm a
var [Char]
"lt")]

coreEncodeLetDef :: TElement (Let -> Term)
coreEncodeLetDef :: TElement (Let -> Term)
coreEncodeLetDef = [Char] -> Type -> TTerm (Let -> Term) -> TElement (Let -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Let" Type
letT (TTerm (Let -> Term) -> TElement (Let -> Term))
-> TTerm (Let -> Term) -> TElement (Let -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Let -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"l" (TTerm Term -> TTerm (Let -> Term))
-> TTerm Term -> TTerm (Let -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Let [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Let_bindings (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (Name -> TTerm ((LetBinding -> Term) -> [LetBinding] -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((LetBinding -> Term) -> [LetBinding] -> [Any])
-> TTerm (LetBinding -> Term) -> TTerm ([LetBinding] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (LetBinding -> Term) -> TTerm (LetBinding -> Term)
forall a. TElement a -> TTerm a
ref TElement (LetBinding -> Term)
coreEncodeLetBindingDef TTerm ([LetBinding] -> [Any]) -> TTerm [LetBinding] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Let -> [LetBinding])
Core.letBindings TTerm (Let -> [LetBinding]) -> TTerm Let -> TTerm [LetBinding]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Let
forall a. [Char] -> TTerm a
var [Char]
"l")),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Let_environment (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Let -> Term)
Core.letEnvironment TTerm (Let -> Term) -> TTerm Let -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Let
forall a. [Char] -> TTerm a
var [Char]
"l")]

coreEncodeLetBindingDef :: TElement (LetBinding -> Term)
coreEncodeLetBindingDef :: TElement (LetBinding -> Term)
coreEncodeLetBindingDef = [Char]
-> Type
-> TTerm (LetBinding -> Term)
-> TElement (LetBinding -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"LetBinding" Type
letBindingT (TTerm (LetBinding -> Term) -> TElement (LetBinding -> Term))
-> TTerm (LetBinding -> Term) -> TElement (LetBinding -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (LetBinding -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"b" (TTerm Term -> TTerm (LetBinding -> Term))
-> TTerm Term -> TTerm (LetBinding -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_LetBinding [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_LetBinding_name (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LetBinding -> Name)
Core.letBindingName TTerm (LetBinding -> Name) -> TTerm LetBinding -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm LetBinding
forall a. [Char] -> TTerm a
var [Char]
"b"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_LetBinding_term (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LetBinding -> Term)
Core.letBindingTerm TTerm (LetBinding -> Term) -> TTerm LetBinding -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm LetBinding
forall a. [Char] -> TTerm a
var [Char]
"b"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_LetBinding_type (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (Maybe Any) -> TTerm Term
forall a. TTerm (Maybe a) -> TTerm Term
encodedOptional (TTerm (Maybe Any) -> TTerm Term)
-> TTerm (Maybe Any) -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name
-> TTerm ((TypeScheme -> Term) -> Maybe TypeScheme -> Maybe Any)
forall a. Name -> TTerm a
primitive Name
_optionals_map TTerm ((TypeScheme -> Term) -> Maybe TypeScheme -> Maybe Any)
-> TTerm (TypeScheme -> Term)
-> TTerm (Maybe TypeScheme -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (TypeScheme -> Term) -> TTerm (TypeScheme -> Term)
forall a. TElement a -> TTerm a
ref TElement (TypeScheme -> Term)
coreEncodeTypeSchemeDef TTerm (Maybe TypeScheme -> Maybe Any)
-> TTerm (Maybe TypeScheme) -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (LetBinding -> Maybe TypeScheme)
Core.letBindingType TTerm (LetBinding -> Maybe TypeScheme)
-> TTerm LetBinding -> TTerm (Maybe TypeScheme)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm LetBinding
forall a. [Char] -> TTerm a
var [Char]
"b")]

coreEncodeLiteralDef :: TElement (Literal -> Term)
coreEncodeLiteralDef :: TElement (Literal -> Term)
coreEncodeLiteralDef = [Char]
-> Type -> TTerm (Literal -> Term) -> TElement (Literal -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Literal" Type
literalT (TTerm (Literal -> Term) -> TElement (Literal -> Term))
-> TTerm (Literal -> Term) -> TElement (Literal -> Term)
forall a b. (a -> b) -> a -> b
$
  Name -> Maybe (TTerm Term) -> [Field] -> TTerm (Literal -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_Literal Maybe (TTerm Term)
forall a. Maybe a
Nothing [
    Name -> TTerm Term -> Field
varField Name
_Literal_binary (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Char] -> TTerm Term
encodedBinary (TTerm [Char] -> TTerm Term) -> TTerm [Char] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm [Char]
forall a. [Char] -> TTerm a
var [Char]
"v",
    Name -> TTerm Term -> Field
varField Name
_Literal_boolean (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Bool -> TTerm Term
encodedBoolean (TTerm Bool -> TTerm Term) -> TTerm Bool -> TTerm Term
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Bool
forall a. [Char] -> TTerm a
var [Char]
"v",
    Name -> TTerm Term -> Field
varField Name
_Literal_float (TElement (FloatValue -> Term) -> TTerm (FloatValue -> Term)
forall a. TElement a -> TTerm a
ref TElement (FloatValue -> Term)
coreEncodeFloatValueDef TTerm (FloatValue -> Term) -> TTerm FloatValue -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm FloatValue
forall a. [Char] -> TTerm a
var [Char]
"v"),
    Name -> TTerm Term -> Field
varField Name
_Literal_integer (TElement (IntegerValue -> Term) -> TTerm (IntegerValue -> Term)
forall a. TElement a -> TTerm a
ref TElement (IntegerValue -> Term)
coreEncodeIntegerValueDef TTerm (IntegerValue -> Term) -> TTerm IntegerValue -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm IntegerValue
forall a. [Char] -> TTerm a
var [Char]
"v"),
    Name -> TTerm Term -> Field
varField Name
_Literal_string (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Char] -> TTerm Term
encodedString (TTerm [Char] -> TTerm Term) -> TTerm [Char] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm [Char]
forall a. [Char] -> TTerm a
var [Char]
"v"]
  where
    varField :: Name -> TTerm Term -> Field
varField Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field)
-> (TTerm Term -> TTerm (Any -> Any)) -> TTerm Term -> Field
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm (Any -> Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_Literal Name
fname

coreEncodeLiteralTypeDef :: TElement (LiteralType -> Term)
coreEncodeLiteralTypeDef :: TElement (LiteralType -> Term)
coreEncodeLiteralTypeDef = [Char]
-> Type
-> TTerm (LiteralType -> Term)
-> TElement (LiteralType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"LiteralType" Type
literalTypeT (TTerm (LiteralType -> Term) -> TElement (LiteralType -> Term))
-> TTerm (LiteralType -> Term) -> TElement (LiteralType -> Term)
forall a b. (a -> b) -> a -> b
$
  Name
-> Maybe (TTerm Term) -> [Field] -> TTerm (LiteralType -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_LiteralType Maybe (TTerm Term)
forall a. Maybe a
Nothing [
    Name -> Field
csunit Name
_LiteralType_binary,
    Name -> Field
csunit Name
_LiteralType_boolean,
    Name -> TElement (FloatType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
cs Name
_LiteralType_float TElement (FloatType -> Term)
coreEncodeFloatTypeDef,
    Name -> TElement (IntegerType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
cs Name
_LiteralType_integer TElement (IntegerType -> Term)
coreEncodeIntegerTypeDef,
    Name -> Field
csunit Name
_LiteralType_string]
  where
    cs :: Name -> TElement (a -> Term) -> Field
cs Name
fname TElement (a -> Term)
fun = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> TTerm Term -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_LiteralType Name
fname (TElement (a -> Term) -> TTerm (a -> Term)
forall a. TElement a -> TTerm a
ref TElement (a -> Term)
fun TTerm (a -> Term) -> TTerm a -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm a
forall a. [Char] -> TTerm a
var [Char]
"v")
    csunit :: Name -> Field
csunit Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Any -> TTerm (Any -> Any)
forall a b. TTerm a -> TTerm (b -> a)
constant (TTerm Any -> TTerm (Any -> Any))
-> TTerm Any -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Term -> TTerm Any
forall a. Term -> TTerm a
TTerm (Term -> TTerm Any) -> Term -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Term -> Term
coreEncodeTerm (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ TTerm Any -> Term
forall a. TTerm a -> Term
unTTerm (TTerm Any -> Term) -> TTerm Any -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any -> TTerm Any
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_LiteralType Name
fname TTerm Any
forall a. TTerm a
unit

coreEncodeMapTypeDef :: TElement (MapType -> Term)
coreEncodeMapTypeDef :: TElement (MapType -> Term)
coreEncodeMapTypeDef = [Char]
-> Type -> TTerm (MapType -> Term) -> TElement (MapType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"MapType" Type
mapTypeT (TTerm (MapType -> Term) -> TElement (MapType -> Term))
-> TTerm (MapType -> Term) -> TElement (MapType -> Term)
forall a b. (a -> b) -> a -> b
$
    [Char] -> TTerm Term -> TTerm (MapType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"mt" (TTerm Term -> TTerm (MapType -> Term))
-> TTerm Term -> TTerm (MapType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_MapType [
      Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_MapType_keys (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (MapType -> Type)
Core.mapTypeKeys TTerm (MapType -> Type) -> TTerm MapType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm MapType
forall a. [Char] -> TTerm a
var [Char]
"mt"),
      Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_MapType_values (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (MapType -> Type)
Core.mapTypeValues TTerm (MapType -> Type) -> TTerm MapType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm MapType
forall a. [Char] -> TTerm a
var [Char]
"mt")]

coreEncodeNameDef :: TElement (Name -> Term)
coreEncodeNameDef :: TElement (Name -> Term)
coreEncodeNameDef = [Char] -> Type -> TTerm (Name -> Term) -> TElement (Name -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Name" Type
nameT (TTerm (Name -> Term) -> TElement (Name -> Term))
-> TTerm (Name -> Term) -> TElement (Name -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Name -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"fn" (TTerm Term -> TTerm (Name -> Term))
-> TTerm Term -> TTerm (Name -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> TTerm Term -> TTerm Term
encodedWrappedTerm Name
_Name (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm [Char] -> TTerm Term
encodedString (TTerm [Char] -> TTerm Term) -> TTerm [Char] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm (Any -> [Char])
forall a b. Name -> TTerm (a -> b)
unwrap Name
_Name TTerm (Any -> [Char]) -> TTerm Any -> TTerm [Char]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"fn"

coreEncodeOptionalCasesDef :: TElement (OptionalCases -> Term)
coreEncodeOptionalCasesDef :: TElement (OptionalCases -> Term)
coreEncodeOptionalCasesDef = [Char]
-> Type
-> TTerm (OptionalCases -> Term)
-> TElement (OptionalCases -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"OptionalCases" Type
optionalCasesT (TTerm (OptionalCases -> Term) -> TElement (OptionalCases -> Term))
-> TTerm (OptionalCases -> Term)
-> TElement (OptionalCases -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (OptionalCases -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"oc" (TTerm Term -> TTerm (OptionalCases -> Term))
-> TTerm Term -> TTerm (OptionalCases -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_OptionalCases [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_OptionalCases_nothing (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (OptionalCases -> Term)
Core.optionalCasesNothing TTerm (OptionalCases -> Term) -> TTerm OptionalCases -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm OptionalCases
forall a. [Char] -> TTerm a
var [Char]
"oc"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_OptionalCases_just (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (OptionalCases -> Term)
Core.optionalCasesJust TTerm (OptionalCases -> Term) -> TTerm OptionalCases -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm OptionalCases
forall a. [Char] -> TTerm a
var [Char]
"oc")]

coreEncodeProjectionDef :: TElement (Projection -> Term)
coreEncodeProjectionDef :: TElement (Projection -> Term)
coreEncodeProjectionDef = [Char]
-> Type
-> TTerm (Projection -> Term)
-> TElement (Projection -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Projection" Type
projectionT (TTerm (Projection -> Term) -> TElement (Projection -> Term))
-> TTerm (Projection -> Term) -> TElement (Projection -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Projection -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"p" (TTerm Term -> TTerm (Projection -> Term))
-> TTerm Term -> TTerm (Projection -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Projection [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Projection_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Projection -> Name)
Core.projectionTypeName TTerm (Projection -> Name) -> TTerm Projection -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Projection
forall a. [Char] -> TTerm a
var [Char]
"p"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Projection_field (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Projection -> Name)
Core.projectionField TTerm (Projection -> Name) -> TTerm Projection -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Projection
forall a. [Char] -> TTerm a
var [Char]
"p")]

coreEncodeRecordDef :: TElement (Record -> Term)
coreEncodeRecordDef :: TElement (Record -> Term)
coreEncodeRecordDef = [Char]
-> Type -> TTerm (Record -> Term) -> TElement (Record -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Record" Type
recordT (TTerm (Record -> Term) -> TElement (Record -> Term))
-> TTerm (Record -> Term) -> TElement (Record -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Record -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"r" (TTerm Term -> TTerm (Record -> Term))
-> TTerm Term -> TTerm (Record -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Record [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Record_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Record -> Name)
Core.recordTypeName TTerm (Record -> Name) -> TTerm Record -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Record
forall a. [Char] -> TTerm a
var [Char]
"r"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Record_fields (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (Name -> TTerm ((Field -> Term) -> [Field] -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Field -> Term) -> [Field] -> [Any])
-> TTerm (Field -> Term) -> TTerm ([Field] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Field -> Term) -> TTerm (Field -> Term)
forall a. TElement a -> TTerm a
ref TElement (Field -> Term)
coreEncodeFieldDef) TTerm ([Field] -> [Any]) -> TTerm [Field] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Record -> [Field])
Core.recordFields TTerm (Record -> [Field]) -> TTerm Record -> TTerm [Field]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Record
forall a. [Char] -> TTerm a
var [Char]
"r"))]

coreEncodeRowTypeDef :: TElement (RowType -> Term)
coreEncodeRowTypeDef :: TElement (RowType -> Term)
coreEncodeRowTypeDef = [Char]
-> Type -> TTerm (RowType -> Term) -> TElement (RowType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"RowType" Type
rowTypeT (TTerm (RowType -> Term) -> TElement (RowType -> Term))
-> TTerm (RowType -> Term) -> TElement (RowType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (RowType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"rt" (TTerm Term -> TTerm (RowType -> Term))
-> TTerm Term -> TTerm (RowType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_RowType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_RowType_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (RowType -> Name)
Core.rowTypeTypeName TTerm (RowType -> Name) -> TTerm RowType -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm RowType
forall a. [Char] -> TTerm a
var [Char]
"rt"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_RowType_fields (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (Name -> TTerm ((FieldType -> Term) -> [FieldType] -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((FieldType -> Term) -> [FieldType] -> [Any])
-> TTerm (FieldType -> Term) -> TTerm ([FieldType] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (FieldType -> Term) -> TTerm (FieldType -> Term)
forall a. TElement a -> TTerm a
ref TElement (FieldType -> Term)
coreEncodeFieldTypeDef TTerm ([FieldType] -> [Any]) -> TTerm [FieldType] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (RowType -> [FieldType])
Core.rowTypeFields TTerm (RowType -> [FieldType])
-> TTerm RowType -> TTerm [FieldType]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm RowType
forall a. [Char] -> TTerm a
var [Char]
"rt"))]

coreEncodeSumDef :: TElement (Sum -> Term)
coreEncodeSumDef :: TElement (Sum -> Term)
coreEncodeSumDef = [Char] -> Type -> TTerm (Sum -> Term) -> TElement (Sum -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Sum" Type
sumT (TTerm (Sum -> Term) -> TElement (Sum -> Term))
-> TTerm (Sum -> Term) -> TElement (Sum -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (Sum -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"s" (TTerm Term -> TTerm (Sum -> Term))
-> TTerm Term -> TTerm (Sum -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_Sum [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Sum_index (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Int -> TTerm Term
encodedInt32 (TTerm Int -> TTerm Term) -> TTerm Int -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm (Sum -> Int)
Core.sumIndex TTerm (Sum -> Int) -> TTerm Sum -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Sum
forall a. [Char] -> TTerm a
var [Char]
"s",
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Sum_size (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Int -> TTerm Term
encodedInt32 (TTerm Int -> TTerm Term) -> TTerm Int -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm (Sum -> Int)
Core.sumSize TTerm (Sum -> Int) -> TTerm Sum -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Sum
forall a. [Char] -> TTerm a
var [Char]
"s",
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_Sum_term (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (Sum -> Term)
Core.sumTerm TTerm (Sum -> Term) -> TTerm Sum -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Sum
forall a. [Char] -> TTerm a
var [Char]
"s")]

coreEncodeTermDef :: TElement (Term -> Term)
coreEncodeTermDef :: TElement (Term -> Term)
coreEncodeTermDef = [Char] -> Type -> TTerm (Term -> Term) -> TElement (Term -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Term" Type
termT (TTerm (Term -> Term) -> TElement (Term -> Term))
-> TTerm (Term -> Term) -> TElement (Term -> Term)
forall a b. (a -> b) -> a -> b
$
  Name -> Maybe (TTerm Term) -> [Field] -> TTerm (Term -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_Term (TTerm Term -> Maybe (TTerm Term)
forall a. a -> Maybe a
Just (TTerm Term -> Maybe (TTerm Term))
-> TTerm Term -> Maybe (TTerm Term)
forall a b. (a -> b) -> a -> b
$ TTerm [Char] -> TTerm Term
encodedString (TTerm [Char] -> TTerm Term) -> TTerm [Char] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm [Char]
string [Char]
"not implemented") [
    Name -> TTerm (AnnotatedTerm -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_annotated (TElement (AnnotatedTerm -> Term) -> TTerm (AnnotatedTerm -> Term)
forall a. TElement a -> TTerm a
ref TElement (AnnotatedTerm -> Term)
coreEncodeAnnotatedTermDef),
    Name -> TTerm (Application -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_application (TElement (Application -> Term) -> TTerm (Application -> Term)
forall a. TElement a -> TTerm a
ref TElement (Application -> Term)
coreEncodeApplicationDef),
    Name -> TTerm (Function -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_function (TElement (Function -> Term) -> TTerm (Function -> Term)
forall a. TElement a -> TTerm a
ref TElement (Function -> Term)
coreEncodeFunctionDef),
    Name -> TTerm (Let -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_let (TElement (Let -> Term) -> TTerm (Let -> Term)
forall a. TElement a -> TTerm a
ref TElement (Let -> Term)
coreEncodeLetDef),
    Name -> TTerm (Literal -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_literal (TElement (Literal -> Term) -> TTerm (Literal -> Term)
forall a. TElement a -> TTerm a
ref TElement (Literal -> Term)
coreEncodeLiteralDef),
    Name -> TTerm Term -> Field
ecase' Name
_Term_list (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (TTerm [Any] -> TTerm Term) -> TTerm [Any] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm ((Term -> Term) -> Any -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Term -> Term) -> Any -> [Any])
-> TTerm (Term -> Term) -> TTerm (Any -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef) TTerm (Any -> [Any]) -> TTerm Any -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v",
--     -- TODO: map encoding
--     ecase' _Term_map $ encodedMap
    Name -> TTerm Term -> Field
ecase' Name
_Term_optional (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (Maybe Any) -> TTerm Term
forall a. TTerm (Maybe a) -> TTerm Term
encodedOptional (Name -> TTerm ((Term -> Term) -> Any -> Maybe Any)
forall a. Name -> TTerm a
primitive Name
_optionals_map TTerm ((Term -> Term) -> Any -> Maybe Any)
-> TTerm (Term -> Term) -> TTerm (Any -> Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Any -> Maybe Any) -> TTerm Any -> TTerm (Maybe Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v"),
    Name -> TTerm Term -> Field
ecase' Name
_Term_product (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (Name -> TTerm ((Term -> Term) -> Any -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Term -> Term) -> Any -> [Any])
-> TTerm (Term -> Term) -> TTerm (Any -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Any -> [Any]) -> TTerm Any -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v"),
    Name -> TTerm (Record -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_record (TElement (Record -> Term) -> TTerm (Record -> Term)
forall a. TElement a -> TTerm a
ref TElement (Record -> Term)
coreEncodeRecordDef),
    Name -> TTerm Term -> Field
ecase' Name
_Term_set (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (Set Any) -> TTerm Term
forall a. TTerm (Set a) -> TTerm Term
encodedSet (TTerm (Set Any) -> TTerm Term) -> TTerm (Set Any) -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm ((Term -> Term) -> Any -> Set Any)
forall a. Name -> TTerm a
primitive Name
_sets_map TTerm ((Term -> Term) -> Any -> Set Any)
-> TTerm (Term -> Term) -> TTerm (Any -> Set Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef) TTerm (Any -> Set Any) -> TTerm Any -> TTerm (Set Any)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v",
    Name -> TTerm (Sum -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_sum (TElement (Sum -> Term) -> TTerm (Sum -> Term)
forall a. TElement a -> TTerm a
ref TElement (Sum -> Term)
coreEncodeSumDef),
    Name -> TTerm (TypeAbstraction -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_typeAbstraction (TTerm (TypeAbstraction -> Term) -> Field)
-> TTerm (TypeAbstraction -> Term) -> Field
forall a b. (a -> b) -> a -> b
$ TElement (TypeAbstraction -> Term)
-> TTerm (TypeAbstraction -> Term)
forall a. TElement a -> TTerm a
ref TElement (TypeAbstraction -> Term)
coreEncodeTypeAbstractionDef,
    Name -> TTerm (TypedTerm -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_typeApplication (TTerm (TypedTerm -> Term) -> Field)
-> TTerm (TypedTerm -> Term) -> Field
forall a b. (a -> b) -> a -> b
$ TElement (TypedTerm -> Term) -> TTerm (TypedTerm -> Term)
forall a. TElement a -> TTerm a
ref TElement (TypedTerm -> Term)
coreEncodeTypedTermDef,
    Name -> TTerm (TypedTerm -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_typed (TTerm (TypedTerm -> Term) -> Field)
-> TTerm (TypedTerm -> Term) -> Field
forall a b. (a -> b) -> a -> b
$ TElement (TypedTerm -> Term) -> TTerm (TypedTerm -> Term)
forall a. TElement a -> TTerm a
ref TElement (TypedTerm -> Term)
coreEncodeTypedTermDef,
    Name -> TTerm (Injection -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_union (TElement (Injection -> Term) -> TTerm (Injection -> Term)
forall a. TElement a -> TTerm a
ref TElement (Injection -> Term)
coreEncodeInjectionDef),
    Name -> TTerm (Name -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_variable (TTerm (Name -> Term) -> Field) -> TTerm (Name -> Term) -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef,
    Name -> TTerm (WrappedTerm -> Term) -> Field
forall {a}. Name -> TTerm (a -> Term) -> Field
ecase Name
_Term_wrap (TTerm (WrappedTerm -> Term) -> Field)
-> TTerm (WrappedTerm -> Term) -> Field
forall a b. (a -> b) -> a -> b
$ TElement (WrappedTerm -> Term) -> TTerm (WrappedTerm -> Term)
forall a. TElement a -> TTerm a
ref TElement (WrappedTerm -> Term)
coreEncodeWrappedTermDef]
  where
    ecase :: Name -> TTerm (a -> Term) -> Field
ecase = Name -> Name -> TTerm (a -> Term) -> Field
forall a. Name -> Name -> TTerm (a -> Term) -> Field
encodedCase Name
_Term
    ecase' :: Name -> TTerm Term -> Field
ecase' Name
fname = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field)
-> (TTerm Term -> TTerm (Any -> Any)) -> TTerm Term -> Field
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> (TTerm Term -> TTerm Term) -> TTerm Term -> TTerm (Any -> Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_Term Name
fname

coreEncodeTupleProjectionDef :: TElement (TupleProjection -> Term)
coreEncodeTupleProjectionDef :: TElement (TupleProjection -> Term)
coreEncodeTupleProjectionDef = [Char]
-> Type
-> TTerm (TupleProjection -> Term)
-> TElement (TupleProjection -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"TupleProjection" Type
tupleProjectionT (TTerm (TupleProjection -> Term)
 -> TElement (TupleProjection -> Term))
-> TTerm (TupleProjection -> Term)
-> TElement (TupleProjection -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (TupleProjection -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"tp" (TTerm Term -> TTerm (TupleProjection -> Term))
-> TTerm Term -> TTerm (TupleProjection -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_TupleProjection [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TupleProjection_arity (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Int -> TTerm Term
encodedInt32 (TTerm Int -> TTerm Term) -> TTerm Int -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm (TupleProjection -> Int)
Core.tupleProjectionArity TTerm (TupleProjection -> Int)
-> TTerm TupleProjection -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm TupleProjection
forall a. [Char] -> TTerm a
var [Char]
"tp",
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TupleProjection_index (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm Int -> TTerm Term
encodedInt32 (TTerm Int -> TTerm Term) -> TTerm Int -> TTerm Term
forall a b. (a -> b) -> a -> b
$ TTerm (TupleProjection -> Int)
Core.tupleProjectionIndex TTerm (TupleProjection -> Int)
-> TTerm TupleProjection -> TTerm Int
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm TupleProjection
forall a. [Char] -> TTerm a
var [Char]
"tp"]

coreEncodeTypeDef :: TElement (Type -> Term)
coreEncodeTypeDef :: TElement (Type -> Term)
coreEncodeTypeDef = [Char] -> Type -> TTerm (Type -> Term) -> TElement (Type -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"Type" Type
typeT (TTerm (Type -> Term) -> TElement (Type -> Term))
-> TTerm (Type -> Term) -> TElement (Type -> Term)
forall a b. (a -> b) -> a -> b
$
  Name -> Maybe (TTerm Term) -> [Field] -> TTerm (Type -> Term)
forall b u. Name -> Maybe (TTerm b) -> [Field] -> TTerm (u -> b)
match Name
_Type Maybe (TTerm Term)
forall a. Maybe a
Nothing [
    Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
_Type_annotated (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Any -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Any -> TTerm (Any -> Any))
-> TTerm Any -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Any -> TTerm Any
forall a b. Name -> Name -> TTerm a -> TTerm b
variant Name
_Term Name
_Term_annotated (TTerm Any -> TTerm Any) -> TTerm Any -> TTerm Any
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Any
forall a. Name -> [Field] -> TTerm a
record Name
_AnnotatedTerm [
      Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_subject (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (AnnotatedType -> Type)
Core.annotatedTypeSubject TTerm (AnnotatedType -> Type) -> TTerm AnnotatedType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedType
forall a. [Char] -> TTerm a
var [Char]
"v"),
      Name -> TTerm (Map [Char] Term) -> Field
forall a. Name -> TTerm a -> Field
field Name
_AnnotatedTerm_annotation (TTerm (Map [Char] Term) -> Field)
-> TTerm (Map [Char] Term) -> Field
forall a b. (a -> b) -> a -> b
$ TTerm (AnnotatedType -> Map [Char] Term)
Core.annotatedTypeAnnotation TTerm (AnnotatedType -> Map [Char] Term)
-> TTerm AnnotatedType -> TTerm (Map [Char] Term)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm AnnotatedType
forall a. [Char] -> TTerm a
var [Char]
"v"],
    Name -> TElement (ApplicationType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_application TElement (ApplicationType -> Term)
coreEncodeApplicationTypeDef,
    Name -> TElement (FunctionType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_function TElement (FunctionType -> Term)
coreEncodeFunctionTypeDef,
    Name -> TElement (LambdaType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_lambda TElement (LambdaType -> Term)
coreEncodeLambdaTypeDef,
    Name -> TElement (Type -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_list TElement (Type -> Term)
coreEncodeTypeDef,
    Name -> TElement (LiteralType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_literal TElement (LiteralType -> Term)
coreEncodeLiteralTypeDef,
    Name -> TElement (MapType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_map TElement (MapType -> Term)
coreEncodeMapTypeDef,
    Name -> TElement (Type -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_optional TElement (Type -> Term)
coreEncodeTypeDef,
    Name -> TTerm Term -> Field
cs Name
_Type_product (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (TTerm [Any] -> TTerm Term) -> TTerm [Any] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm ((Type -> Term) -> Any -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Type -> Term) -> Any -> [Any])
-> TTerm (Type -> Term) -> TTerm (Any -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Any -> [Any]) -> TTerm Any -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v",
    Name -> TElement (RowType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_record TElement (RowType -> Term)
coreEncodeRowTypeDef,
    Name -> TElement (Type -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_set TElement (Type -> Term)
coreEncodeTypeDef,
    Name -> TTerm Term -> Field
cs Name
_Type_sum (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (TTerm [Any] -> TTerm Term) -> TTerm [Any] -> TTerm Term
forall a b. (a -> b) -> a -> b
$ Name -> TTerm ((Type -> Term) -> Any -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Type -> Term) -> Any -> [Any])
-> TTerm (Type -> Term) -> TTerm (Any -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Any -> [Any]) -> TTerm Any -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"v",
    Name -> TElement (RowType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_union TElement (RowType -> Term)
coreEncodeRowTypeDef,
    Name -> TElement (Name -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_variable TElement (Name -> Term)
coreEncodeNameDef,
    Name -> TElement (WrappedType -> Term) -> Field
forall {a}. Name -> TElement (a -> Term) -> Field
csref Name
_Type_wrap TElement (WrappedType -> Term)
coreEncodeWrappedTypeDef]
  where
    cs :: Name -> TTerm Term -> Field
cs Name
fname TTerm Term
term = Name -> TTerm (Any -> Any) -> Field
forall a. Name -> TTerm a -> Field
field Name
fname (TTerm (Any -> Any) -> Field) -> TTerm (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> TTerm Term -> TTerm (Any -> Any)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"v" (TTerm Term -> TTerm (Any -> Any))
-> TTerm Term -> TTerm (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> TTerm Term -> TTerm Term
encodedVariant Name
_Type Name
fname TTerm Term
term
    csref :: Name -> TElement (a -> Term) -> Field
csref Name
fname TElement (a -> Term)
fun = Name -> TTerm Term -> Field
cs Name
fname (TElement (a -> Term) -> TTerm (a -> Term)
forall a. TElement a -> TTerm a
ref TElement (a -> Term)
fun TTerm (a -> Term) -> TTerm a -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm a
forall a. [Char] -> TTerm a
var [Char]
"v")

coreEncodeTypeAbstractionDef :: TElement (TypeAbstraction -> Term)
coreEncodeTypeAbstractionDef :: TElement (TypeAbstraction -> Term)
coreEncodeTypeAbstractionDef = [Char]
-> Type
-> TTerm (TypeAbstraction -> Term)
-> TElement (TypeAbstraction -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"TypeAbstraction" Type
typeAbstractionT (TTerm (TypeAbstraction -> Term)
 -> TElement (TypeAbstraction -> Term))
-> TTerm (TypeAbstraction -> Term)
-> TElement (TypeAbstraction -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (TypeAbstraction -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"l" (TTerm Term -> TTerm (TypeAbstraction -> Term))
-> TTerm Term -> TTerm (TypeAbstraction -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_TypeAbstraction [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypeAbstraction_parameter (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (Name -> Name -> TTerm (Any -> Name)
forall a b. Name -> Name -> TTerm (a -> b)
project Name
_TypeAbstraction Name
_TypeAbstraction_parameter TTerm (Any -> Name) -> TTerm Any -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"l"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypeAbstraction_body (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (Name -> Name -> TTerm (Any -> Term)
forall a b. Name -> Name -> TTerm (a -> b)
project Name
_TypeAbstraction Name
_TypeAbstraction_body TTerm (Any -> Term) -> TTerm Any -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"l")]

coreEncodeTypeSchemeDef :: TElement (TypeScheme -> Term)
coreEncodeTypeSchemeDef :: TElement (TypeScheme -> Term)
coreEncodeTypeSchemeDef = [Char]
-> Type
-> TTerm (TypeScheme -> Term)
-> TElement (TypeScheme -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"TypeScheme" Type
typeSchemeT (TTerm (TypeScheme -> Term) -> TElement (TypeScheme -> Term))
-> TTerm (TypeScheme -> Term) -> TElement (TypeScheme -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (TypeScheme -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"ts" (TTerm Term -> TTerm (TypeScheme -> Term))
-> TTerm Term -> TTerm (TypeScheme -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_TypeScheme [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypeScheme_variables (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TTerm [Any] -> TTerm Term
forall a. TTerm [a] -> TTerm Term
encodedList (Name -> TTerm ((Name -> Term) -> [Name] -> [Any])
forall a. Name -> TTerm a
primitive Name
_lists_map TTerm ((Name -> Term) -> [Name] -> [Any])
-> TTerm (Name -> Term) -> TTerm ([Name] -> [Any])
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm ([Name] -> [Any]) -> TTerm [Name] -> TTerm [Any]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (TypeScheme -> [Name])
Core.typeSchemeVariables TTerm (TypeScheme -> [Name]) -> TTerm TypeScheme -> TTerm [Name]
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm TypeScheme
forall a. [Char] -> TTerm a
var [Char]
"ts")),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypeScheme_type (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (TypeScheme -> Type)
Core.typeSchemeType TTerm (TypeScheme -> Type) -> TTerm TypeScheme -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm TypeScheme
forall a. [Char] -> TTerm a
var [Char]
"ts")]

coreEncodeTypedTermDef :: TElement (TypedTerm -> Term)
coreEncodeTypedTermDef :: TElement (TypedTerm -> Term)
coreEncodeTypedTermDef = [Char]
-> Type
-> TTerm (TypedTerm -> Term)
-> TElement (TypedTerm -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"TypedTerm" Type
typedTermT (TTerm (TypedTerm -> Term) -> TElement (TypedTerm -> Term))
-> TTerm (TypedTerm -> Term) -> TElement (TypedTerm -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (TypedTerm -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"tt" (TTerm Term -> TTerm (TypedTerm -> Term))
-> TTerm Term -> TTerm (TypedTerm -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_TypedTerm [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypedTerm_term (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (Name -> Name -> TTerm (Any -> Term)
forall a b. Name -> Name -> TTerm (a -> b)
project Name
_TypedTerm Name
_TypedTerm_term TTerm (Any -> Term) -> TTerm Any -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"tt"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_TypedTerm_type (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (Name -> Name -> TTerm (Any -> Type)
forall a b. Name -> Name -> TTerm (a -> b)
project Name
_TypedTerm Name
_TypedTerm_type TTerm (Any -> Type) -> TTerm Any -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm Any
forall a. [Char] -> TTerm a
var [Char]
"tt")]

coreEncodeWrappedTermDef :: TElement (WrappedTerm -> Term)
coreEncodeWrappedTermDef :: TElement (WrappedTerm -> Term)
coreEncodeWrappedTermDef = [Char]
-> Type
-> TTerm (WrappedTerm -> Term)
-> TElement (WrappedTerm -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"WrappedTerm" Type
wrappedTermT (TTerm (WrappedTerm -> Term) -> TElement (WrappedTerm -> Term))
-> TTerm (WrappedTerm -> Term) -> TElement (WrappedTerm -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (WrappedTerm -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"n" (TTerm Term -> TTerm (WrappedTerm -> Term))
-> TTerm Term -> TTerm (WrappedTerm -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_WrappedTerm [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_WrappedTerm_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (WrappedTerm -> Name)
Core.wrappedTermTypeName TTerm (WrappedTerm -> Name) -> TTerm WrappedTerm -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm WrappedTerm
forall a. [Char] -> TTerm a
var [Char]
"n"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_WrappedTerm_object (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Term -> Term) -> TTerm (Term -> Term)
forall a. TElement a -> TTerm a
ref TElement (Term -> Term)
coreEncodeTermDef TTerm (Term -> Term) -> TTerm Term -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (WrappedTerm -> Term)
Core.wrappedTermObject TTerm (WrappedTerm -> Term) -> TTerm WrappedTerm -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm WrappedTerm
forall a. [Char] -> TTerm a
var [Char]
"n")]

coreEncodeWrappedTypeDef :: TElement (WrappedType -> Term)
coreEncodeWrappedTypeDef :: TElement (WrappedType -> Term)
coreEncodeWrappedTypeDef = [Char]
-> Type
-> TTerm (WrappedType -> Term)
-> TElement (WrappedType -> Term)
forall x. [Char] -> Type -> TTerm x -> TElement x
coreEncodingDefinition [Char]
"WrappedType" Type
wrappedTypeT (TTerm (WrappedType -> Term) -> TElement (WrappedType -> Term))
-> TTerm (WrappedType -> Term) -> TElement (WrappedType -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> TTerm Term -> TTerm (WrappedType -> Term)
forall x a b. [Char] -> TTerm x -> TTerm (a -> b)
lambda [Char]
"nt" (TTerm Term -> TTerm (WrappedType -> Term))
-> TTerm Term -> TTerm (WrappedType -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> TTerm Term
encodedRecord Name
_WrappedType [
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_WrappedType_typeName (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Name -> Term) -> TTerm (Name -> Term)
forall a. TElement a -> TTerm a
ref TElement (Name -> Term)
coreEncodeNameDef TTerm (Name -> Term) -> TTerm Name -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (WrappedType -> Name)
Core.wrappedTypeTypeName TTerm (WrappedType -> Name) -> TTerm WrappedType -> TTerm Name
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm WrappedType
forall a. [Char] -> TTerm a
var [Char]
"nt"),
    Name -> TTerm Term -> Field
forall a. Name -> TTerm a -> Field
field Name
_WrappedType_object (TTerm Term -> Field) -> TTerm Term -> Field
forall a b. (a -> b) -> a -> b
$ TElement (Type -> Term) -> TTerm (Type -> Term)
forall a. TElement a -> TTerm a
ref TElement (Type -> Term)
coreEncodeTypeDef TTerm (Type -> Term) -> TTerm Type -> TTerm Term
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ (TTerm (WrappedType -> Type)
Core.wrappedTypeObject TTerm (WrappedType -> Type) -> TTerm WrappedType -> TTerm Type
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ [Char] -> TTerm WrappedType
forall a. [Char] -> TTerm a
var [Char]
"nt")]