{-# 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 = [
     Definition (AnnotatedTerm -> Term) -> Element
forall a. Definition a -> Element
el Definition (AnnotatedTerm -> Term)
coreEncodeAnnotatedTermDef,
     Definition (AnnotatedType -> Term) -> Element
forall a. Definition a -> Element
el Definition (AnnotatedType -> Term)
coreEncodeAnnotatedTypeDef,
     Definition (Application -> Term) -> Element
forall a. Definition a -> Element
el Definition (Application -> Term)
coreEncodeApplicationDef,
     Definition (ApplicationType -> Term) -> Element
forall a. Definition a -> Element
el Definition (ApplicationType -> Term)
coreEncodeApplicationTypeDef,
     Definition (CaseStatement -> Term) -> Element
forall a. Definition a -> Element
el Definition (CaseStatement -> Term)
coreEncodeCaseStatementDef,
     Definition (Elimination -> Term) -> Element
forall a. Definition a -> Element
el Definition (Elimination -> Term)
coreEncodeEliminationDef,
     Definition (Field -> Term) -> Element
forall a. Definition a -> Element
el Definition (Field -> Term)
coreEncodeFieldDef,
     Definition (FieldType -> Term) -> Element
forall a. Definition a -> Element
el Definition (FieldType -> Term)
coreEncodeFieldTypeDef,
     Definition (FloatType -> Term) -> Element
forall a. Definition a -> Element
el Definition (FloatType -> Term)
coreEncodeFloatTypeDef,
     Definition (FloatValue -> Term) -> Element
forall a. Definition a -> Element
el Definition (FloatValue -> Term)
coreEncodeFloatValueDef,
     Definition (Function -> Term) -> Element
forall a. Definition a -> Element
el Definition (Function -> Term)
coreEncodeFunctionDef,
     Definition (FunctionType -> Term) -> Element
forall a. Definition a -> Element
el Definition (FunctionType -> Term)
coreEncodeFunctionTypeDef,
     Definition (Injection -> Term) -> Element
forall a. Definition a -> Element
el Definition (Injection -> Term)
coreEncodeInjectionDef,
     Definition (IntegerType -> Term) -> Element
forall a. Definition a -> Element
el Definition (IntegerType -> Term)
coreEncodeIntegerTypeDef,
     Definition (IntegerValue -> Term) -> Element
forall a. Definition a -> Element
el Definition (IntegerValue -> Term)
coreEncodeIntegerValueDef,
     Definition (Lambda -> Term) -> Element
forall a. Definition a -> Element
el Definition (Lambda -> Term)
coreEncodeLambdaDef,
     Definition (LambdaType -> Term) -> Element
forall a. Definition a -> Element
el Definition (LambdaType -> Term)
coreEncodeLambdaTypeDef,
     Definition (Let -> Term) -> Element
forall a. Definition a -> Element
el Definition (Let -> Term)
coreEncodeLetDef,
     Definition (LetBinding -> Term) -> Element
forall a. Definition a -> Element
el Definition (LetBinding -> Term)
coreEncodeLetBindingDef,
     Definition (Literal -> Term) -> Element
forall a. Definition a -> Element
el Definition (Literal -> Term)
coreEncodeLiteralDef,
     Definition (LiteralType -> Term) -> Element
forall a. Definition a -> Element
el Definition (LiteralType -> Term)
coreEncodeLiteralTypeDef,
     Definition (MapType -> Term) -> Element
forall a. Definition a -> Element
el Definition (MapType -> Term)
coreEncodeMapTypeDef,
     Definition (Name -> Term) -> Element
forall a. Definition a -> Element
el Definition (Name -> Term)
coreEncodeNameDef,
     Definition (OptionalCases -> Term) -> Element
forall a. Definition a -> Element
el Definition (OptionalCases -> Term)
coreEncodeOptionalCasesDef,
     Definition (Projection -> Term) -> Element
forall a. Definition a -> Element
el Definition (Projection -> Term)
coreEncodeProjectionDef,
     Definition (Record -> Term) -> Element
forall a. Definition a -> Element
el Definition (Record -> Term)
coreEncodeRecordDef,
     Definition (RowType -> Term) -> Element
forall a. Definition a -> Element
el Definition (RowType -> Term)
coreEncodeRowTypeDef,
     Definition (Sum -> Term) -> Element
forall a. Definition a -> Element
el Definition (Sum -> Term)
coreEncodeSumDef,
     Definition (Term -> Term) -> Element
forall a. Definition a -> Element
el Definition (Term -> Term)
coreEncodeTermDef,
     Definition (TupleProjection -> Term) -> Element
forall a. Definition a -> Element
el Definition (TupleProjection -> Term)
coreEncodeTupleProjectionDef,
     Definition (Type -> Term) -> Element
forall a. Definition a -> Element
el Definition (Type -> Term)
coreEncodeTypeDef,
     Definition (TypeScheme -> Term) -> Element
forall a. Definition a -> Element
el Definition (TypeScheme -> Term)
coreEncodeTypeSchemeDef,
     Definition (WrappedTerm -> Term) -> Element
forall a. Definition a -> Element
el Definition (WrappedTerm -> Term)
coreEncodeWrappedTermDef,
     Definition (WrappedType -> Term) -> Element
forall a. Definition a -> Element
el Definition (WrappedType -> Term)
coreEncodeWrappedTypeDef]

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

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

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

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

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

encodedFieldRaw :: Datum Name -> Datum Term -> Datum Term
encodedFieldRaw :: Datum Name -> Datum Term -> Datum Term
encodedFieldRaw (Datum Term
fname) (Datum Term
term) = Term -> Datum Term
forall a. Term -> Datum a
Datum (Term -> Datum Term) -> Term -> Datum 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 :: Datum FloatValue -> Datum Term
encodedFloatValue :: Datum FloatValue -> Datum Term
encodedFloatValue = Datum Literal -> Datum Term
encodedLiteral (Datum Literal -> Datum Term)
-> (Datum FloatValue -> Datum Literal)
-> Datum FloatValue
-> Datum Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Datum FloatValue -> Datum Literal
Core.literalFloat

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

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

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

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

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

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

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

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

encodedWrappedTermRaw :: Datum Name -> Datum Term -> Datum Term
encodedWrappedTermRaw :: Datum Name -> Datum Term -> Datum Term
encodedWrappedTermRaw (Datum Term
name) (Datum Term
term) = Term -> Datum Term
forall a. Term -> Datum a
Datum (Term -> Datum Term) -> Term -> Datum 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 :: Datum (Maybe a) -> Datum Term
encodedOptional :: forall a. Datum (Maybe a) -> Datum Term
encodedOptional = Name -> Name -> Datum (Maybe a) -> Datum Term
forall a b. Name -> Name -> Datum a -> Datum b
variant Name
_Term Name
_Term_optional

encodedRecord :: Name -> [Field] -> Datum Term
encodedRecord :: Name -> [Field] -> Datum Term
encodedRecord Name
tname [Field]
fields = Term -> Datum Term
forall a. Term -> Datum a
Datum (Term -> Datum Term) -> Term -> Datum 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 -> Datum Name -> Field
forall a. Name -> Datum a -> Field
field Name
_Record_typeName (Datum Name -> Field) -> Datum Name -> Field
forall a b. (a -> b) -> a -> b
$ Name -> Datum Name
encodedName Name
tname,
    Name -> Datum [Term] -> Field
forall a. Name -> Datum a -> Field
field Name
_Record_fields (Datum [Term] -> Field) -> Datum [Term] -> Field
forall a b. (a -> b) -> a -> b
$ [Datum Term] -> Datum [Term]
forall a. [Datum a] -> Datum [a]
list (Field -> Datum Term
encField (Field -> Datum Term) -> [Field] -> [Datum Term]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Field]
fields)]
  where
    encField :: Field -> Datum Term
encField (Field Name
fname Term
term) = Name -> Datum Term -> Datum Term
encodedField Name
fname (Datum Term -> Datum Term) -> Datum Term -> Datum Term
forall a b. (a -> b) -> a -> b
$ Term -> Datum Term
forall a. Term -> Datum a
Datum Term
term

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

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

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

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

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

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

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

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

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

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

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

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

coreEncodeFloatTypeDef :: Definition (FloatType -> Term)
coreEncodeFloatTypeDef :: Definition (FloatType -> Term)
coreEncodeFloatTypeDef = [Char]
-> Type
-> Datum (FloatType -> Term)
-> Definition (FloatType -> Term)
forall x. [Char] -> Type -> Datum x -> Definition x
coreEncodingDefinition [Char]
"FloatType" Type
floatTypeT (Datum (FloatType -> Term) -> Definition (FloatType -> Term))
-> Datum (FloatType -> Term) -> Definition (FloatType -> Term)
forall a b. (a -> b) -> a -> b
$
    Name -> Maybe (Datum Term) -> [Field] -> Datum (FloatType -> Term)
forall b u. Name -> Maybe (Datum b) -> [Field] -> Datum (u -> b)
match Name
_FloatType Maybe (Datum 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 -> Datum (Any -> Any) -> Field
forall a. Name -> Datum a -> Field
field Name
fname (Datum (Any -> Any) -> Field) -> Datum (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ Datum Any -> Datum (Any -> Any)
forall a b. Datum a -> Datum (b -> a)
constant (Datum Any -> Datum (Any -> Any))
-> Datum Any -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Term -> Datum Any
forall a. Term -> Datum a
Datum (Term -> Datum Any) -> Term -> Datum Any
forall a b. (a -> b) -> a -> b
$ Term -> Term
coreEncodeTerm (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ Datum Any -> Term
forall a. Datum a -> Term
unDatum (Datum Any -> Term) -> Datum Any -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Datum Any
forall a. Name -> Name -> Datum a
unitVariant Name
_FloatType Name
fname

coreEncodeFloatValueDef :: Definition (FloatValue -> Term)
coreEncodeFloatValueDef :: Definition (FloatValue -> Term)
coreEncodeFloatValueDef = [Char]
-> Type
-> Datum (FloatValue -> Term)
-> Definition (FloatValue -> Term)
forall x. [Char] -> Type -> Datum x -> Definition x
coreEncodingDefinition [Char]
"FloatValue" Type
floatValueT (Datum (FloatValue -> Term) -> Definition (FloatValue -> Term))
-> Datum (FloatValue -> Term) -> Definition (FloatValue -> Term)
forall a b. (a -> b) -> a -> b
$
  Name -> Maybe (Datum Term) -> [Field] -> Datum (FloatValue -> Term)
forall b u. Name -> Maybe (Datum b) -> [Field] -> Datum (u -> b)
match Name
_FloatValue Maybe (Datum 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 -> Datum (Any -> Any) -> Field
forall a. Name -> Datum a -> Field
field Name
fname (Datum (Any -> Any) -> Field) -> Datum (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> Datum Term -> Datum (Any -> Any)
forall x a b. [Char] -> Datum x -> Datum (a -> b)
lambda [Char]
"v" (Datum Term -> Datum (Any -> Any))
-> Datum Term -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Datum Term -> Datum Term
encodedVariant Name
_FloatValue Name
fname (Datum Term -> Datum Term) -> Datum Term -> Datum Term
forall a b. (a -> b) -> a -> b
$ Datum FloatValue -> Datum Term
encodedFloatValue (Datum FloatValue -> Datum Term) -> Datum FloatValue -> Datum Term
forall a b. (a -> b) -> a -> b
$
      Name -> Name -> Datum Any -> Datum FloatValue
forall a b. Name -> Name -> Datum a -> Datum b
variant Name
_FloatValue Name
fname (Datum Any -> Datum FloatValue) -> Datum Any -> Datum FloatValue
forall a b. (a -> b) -> a -> b
$ [Char] -> Datum Any
forall a. [Char] -> Datum a
var [Char]
"v"

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

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

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

coreEncodeIntegerTypeDef :: Definition (IntegerType -> Term)
coreEncodeIntegerTypeDef :: Definition (IntegerType -> Term)
coreEncodeIntegerTypeDef = [Char]
-> Type
-> Datum (IntegerType -> Term)
-> Definition (IntegerType -> Term)
forall x. [Char] -> Type -> Datum x -> Definition x
coreEncodingDefinition [Char]
"IntegerType" Type
integerTypeT (Datum (IntegerType -> Term) -> Definition (IntegerType -> Term))
-> Datum (IntegerType -> Term) -> Definition (IntegerType -> Term)
forall a b. (a -> b) -> a -> b
$
    Name
-> Maybe (Datum Term) -> [Field] -> Datum (IntegerType -> Term)
forall b u. Name -> Maybe (Datum b) -> [Field] -> Datum (u -> b)
match Name
_IntegerType Maybe (Datum 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 -> Datum (Any -> Any) -> Field
forall a. Name -> Datum a -> Field
field Name
fname (Datum (Any -> Any) -> Field) -> Datum (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ Datum Any -> Datum (Any -> Any)
forall a b. Datum a -> Datum (b -> a)
constant (Datum Any -> Datum (Any -> Any))
-> Datum Any -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Term -> Datum Any
forall a. Term -> Datum a
Datum (Term -> Datum Any) -> Term -> Datum Any
forall a b. (a -> b) -> a -> b
$ Term -> Term
coreEncodeTerm (Term -> Term) -> Term -> Term
forall a b. (a -> b) -> a -> b
$ Datum Any -> Term
forall a. Datum a -> Term
unDatum (Datum Any -> Term) -> Datum Any -> Term
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Datum Any
forall a. Name -> Name -> Datum a
unitVariant Name
_IntegerType Name
fname

coreEncodeIntegerValueDef :: Definition (IntegerValue -> Term)
coreEncodeIntegerValueDef :: Definition (IntegerValue -> Term)
coreEncodeIntegerValueDef = [Char]
-> Type
-> Datum (IntegerValue -> Term)
-> Definition (IntegerValue -> Term)
forall x. [Char] -> Type -> Datum x -> Definition x
coreEncodingDefinition [Char]
"IntegerValue" Type
integerValueT (Datum (IntegerValue -> Term) -> Definition (IntegerValue -> Term))
-> Datum (IntegerValue -> Term)
-> Definition (IntegerValue -> Term)
forall a b. (a -> b) -> a -> b
$
  Name
-> Maybe (Datum Term) -> [Field] -> Datum (IntegerValue -> Term)
forall b u. Name -> Maybe (Datum b) -> [Field] -> Datum (u -> b)
match Name
_IntegerValue Maybe (Datum 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 -> Datum (Any -> Any) -> Field
forall a. Name -> Datum a -> Field
field Name
fname (Datum (Any -> Any) -> Field) -> Datum (Any -> Any) -> Field
forall a b. (a -> b) -> a -> b
$ [Char] -> Datum Term -> Datum (Any -> Any)
forall x a b. [Char] -> Datum x -> Datum (a -> b)
lambda [Char]
"v" (Datum Term -> Datum (Any -> Any))
-> Datum Term -> Datum (Any -> Any)
forall a b. (a -> b) -> a -> b
$ Name -> Name -> Datum Term -> Datum Term
encodedVariant Name
_IntegerValue Name
fname (Datum Term -> Datum Term) -> Datum Term -> Datum Term
forall a b. (a -> b) -> a -> b
$ Datum IntegerValue -> Datum Term
encodedIntegerValue (Datum IntegerValue -> Datum Term)
-> Datum IntegerValue -> Datum Term
forall a b. (a -> b) -> a -> b
$
      Name -> Name -> Datum Any -> Datum IntegerValue
forall a b. Name -> Name -> Datum a -> Datum b
variant Name
_IntegerValue Name
fname (Datum Any -> Datum IntegerValue)
-> Datum Any -> Datum IntegerValue
forall a b. (a -> b) -> a -> b
$ [Char] -> Datum Any
forall a. [Char] -> Datum a
var [Char]
"v"

coreEncodeLambdaDef :: Definition (Lambda -> Term)
coreEncodeLambdaDef :: Definition (Lambda -> Term)
coreEncodeLambdaDef = [Char]
-> Type -> Datum (Lambda -> Term) -> Definition (Lambda -> Term)
forall x. [Char] -> Type -> Datum x -> Definition x
coreEncodingDefinition [Char]
"Lambda" Type
lambdaT (Datum (Lambda -> Term) -> Definition (Lambda -> Term))
-> Datum (Lambda -> Term) -> Definition (Lambda -> Term)
forall a b. (a -> b) -> a -> b
$
  [Char] -> Datum Term -> Datum (Lambda -> Term)
forall x a b. [Char] -> Datum x -> Datum (a -> b)
lambda [Char]
"l" (Datum Term -> Datum (Lambda -> Term))
-> Datum Term -> Datum (Lambda -> Term)
forall a b. (a -> b) -> a -> b
$ Name -> [Field] -> Datum Term
encodedRecord Name
_Lambda [
    Name -> Datum Term -> Field
forall a. Name -> Datum a -> Field
field Name
_Lambda_parameter (Datum Term -> Field) -> Datum Term -> Field
forall a b. (a -> b) -> a -> b
$ Definition (Name -> Term) -> Datum (Name -> Term)
forall a. Definition a -> Datum a
ref Definition (Name -> Term)
coreEncodeNameDef Datum (Name -> Term) -> Datum Name -> Datum Term
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (Lambda -> Name)
Core.lambdaParameter Datum (Lambda -> Name) -> Datum Lambda -> Datum Name
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ [Char] -> Datum Lambda
forall a. [Char] -> Datum a
var [Char]
"l"),
    Name -> Datum Term -> Field
forall a. Name -> Datum a -> Field
field Name
_Lambda_body (Datum Term -> Field) -> Datum Term -> Field
forall a b. (a -> b) -> a -> b
$ Definition (Term -> Term) -> Datum (Term -> Term)
forall a. Definition a -> Datum a
ref Definition (Term -> Term)
coreEncodeTermDef Datum (Term -> Term) -> Datum Term -> Datum Term
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ (Datum (Lambda -> Term)
Core.lambdaBody Datum (Lambda -> Term) -> Datum Lambda -> Datum Term
forall a b. Datum (a -> b) -> Datum a -> Datum b
@@ [Char] -> Datum Lambda
forall a. [Char] -> Datum a
var [Char]
"l")]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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