-- | Mapping of hydra/core constructs in a host language like Haskell or Java  to their native Hydra counterparts as terms.  This includes an implementation of LambdaGraph's epsilon encoding (types to terms).

module Hydra.CoreEncoding where

import qualified Hydra.Core as Core
import qualified Hydra.Lib.Lists as Lists
import qualified Hydra.Lib.Optionals as Optionals
import qualified Hydra.Lib.Sets as Sets
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

coreEncodeAnnotatedTerm :: (Core.AnnotatedTerm -> Core.Term)
coreEncodeAnnotatedTerm :: AnnotatedTerm -> Term
coreEncodeAnnotatedTerm AnnotatedTerm
a = (AnnotatedTerm -> Term
Core.TermAnnotated (Core.AnnotatedTerm {
  annotatedTermSubject :: Term
Core.annotatedTermSubject = (Term -> Term
coreEncodeTerm (AnnotatedTerm -> Term
Core.annotatedTermSubject AnnotatedTerm
a)),
  annotatedTermAnnotation :: Map Name Term
Core.annotatedTermAnnotation = (AnnotatedTerm -> Map Name Term
Core.annotatedTermAnnotation AnnotatedTerm
a)}))

coreEncodeAnnotatedType :: (Core.AnnotatedType -> Core.Term)
coreEncodeAnnotatedType :: AnnotatedType -> Term
coreEncodeAnnotatedType AnnotatedType
at = (AnnotatedTerm -> Term
Core.TermAnnotated (Core.AnnotatedTerm {
  annotatedTermSubject :: Term
Core.annotatedTermSubject = (Type -> Term
coreEncodeType (AnnotatedType -> Type
Core.annotatedTypeSubject AnnotatedType
at)),
  annotatedTermAnnotation :: Map Name Term
Core.annotatedTermAnnotation = (AnnotatedType -> Map Name Term
Core.annotatedTypeAnnotation AnnotatedType
at)}))

coreEncodeApplication :: (Core.Application -> Core.Term)
coreEncodeApplication :: Application -> Term
coreEncodeApplication Application
app = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Application"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"function"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Application -> Term
Core.applicationFunction Application
app))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"argument"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Application -> Term
Core.applicationArgument Application
app))}]}))

coreEncodeApplicationType :: (Core.ApplicationType -> Core.Term)
coreEncodeApplicationType :: ApplicationType -> Term
coreEncodeApplicationType ApplicationType
at = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.ApplicationType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"function"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (ApplicationType -> Type
Core.applicationTypeFunction ApplicationType
at))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"argument"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (ApplicationType -> Type
Core.applicationTypeArgument ApplicationType
at))}]}))

coreEncodeCaseStatement :: (Core.CaseStatement -> Core.Term)
coreEncodeCaseStatement :: CaseStatement -> Term
coreEncodeCaseStatement CaseStatement
cs = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.CaseStatement"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (CaseStatement -> Name
Core.caseStatementTypeName CaseStatement
cs))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"default"),
      fieldTerm :: Term
Core.fieldTerm = (Maybe Term -> Term
Core.TermOptional ((Term -> Term) -> Maybe Term -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map Term -> Term
coreEncodeTerm (CaseStatement -> Maybe Term
Core.caseStatementDefault CaseStatement
cs)))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"cases"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Field -> Term) -> [Field] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Field -> Term
coreEncodeField (CaseStatement -> [Field]
Core.caseStatementCases CaseStatement
cs)))}]}))

coreEncodeElimination :: (Core.Elimination -> Core.Term)
coreEncodeElimination :: Elimination -> Term
coreEncodeElimination Elimination
x = case Elimination
x of
  Core.EliminationList Term
v0 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"list"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm Term
v0)}}))
  Core.EliminationOptional OptionalCases
v1 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"optional"),
      fieldTerm :: Term
Core.fieldTerm = (OptionalCases -> Term
coreEncodeOptionalCases OptionalCases
v1)}}))
  Core.EliminationProduct TupleProjection
v2 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"product"),
      fieldTerm :: Term
Core.fieldTerm = (TupleProjection -> Term
coreEncodeTupleProjection TupleProjection
v2)}}))
  Core.EliminationRecord Projection
v3 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"record"),
      fieldTerm :: Term
Core.fieldTerm = (Projection -> Term
coreEncodeProjection Projection
v3)}}))
  Core.EliminationUnion CaseStatement
v4 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"union"),
      fieldTerm :: Term
Core.fieldTerm = (CaseStatement -> Term
coreEncodeCaseStatement CaseStatement
v4)}}))
  Core.EliminationWrap Name
v5 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Elimination"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"wrap"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName Name
v5)}}))

coreEncodeField :: (Core.Field -> Core.Term)
coreEncodeField :: Field -> Term
coreEncodeField Field
f = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Field"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"name"),
      fieldTerm :: Term
Core.fieldTerm = (WrappedTerm -> Term
Core.TermWrap (Core.WrappedTerm {
        wrappedTermTypeName :: Name
Core.wrappedTermTypeName = (String -> Name
Core.Name String
"hydra/core.Name"),
        wrappedTermObject :: Term
Core.wrappedTermObject = (Literal -> Term
Core.TermLiteral (String -> Literal
Core.LiteralString (Name -> String
Core.unName (Field -> Name
Core.fieldName Field
f))))}))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"term"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Field -> Term
Core.fieldTerm Field
f))}]}))

coreEncodeFieldType :: (Core.FieldType -> Core.Term)
coreEncodeFieldType :: FieldType -> Term
coreEncodeFieldType FieldType
ft = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.FieldType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"name"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (FieldType -> Name
Core.fieldTypeName FieldType
ft))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"type"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (FieldType -> Type
Core.fieldTypeType FieldType
ft))}]}))

coreEncodeFloatType :: (Core.FloatType -> Core.Term)
coreEncodeFloatType :: FloatType -> Term
coreEncodeFloatType FloatType
x = case FloatType
x of
  FloatType
Core.FloatTypeBigfloat -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"bigfloat"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  FloatType
Core.FloatTypeFloat32 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float32"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  FloatType
Core.FloatTypeFloat64 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float64"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))

coreEncodeFloatValue :: (Core.FloatValue -> Core.Term)
coreEncodeFloatValue :: FloatValue -> Term
coreEncodeFloatValue FloatValue
x = case FloatValue
x of
  Core.FloatValueBigfloat Double
v9 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"bigfloat"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (FloatValue -> Literal
Core.LiteralFloat (Double -> FloatValue
Core.FloatValueBigfloat Double
v9)))}}))
  Core.FloatValueFloat32 Float
v10 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float32"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (FloatValue -> Literal
Core.LiteralFloat (Float -> FloatValue
Core.FloatValueFloat32 Float
v10)))}}))
  Core.FloatValueFloat64 Double
v11 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.FloatValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float64"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (FloatValue -> Literal
Core.LiteralFloat (Double -> FloatValue
Core.FloatValueFloat64 Double
v11)))}}))

coreEncodeFunction :: (Core.Function -> Core.Term)
coreEncodeFunction :: Function -> Term
coreEncodeFunction Function
x = case Function
x of
  Core.FunctionElimination Elimination
v12 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Function"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"elimination"),
      fieldTerm :: Term
Core.fieldTerm = (Elimination -> Term
coreEncodeElimination Elimination
v12)}}))
  Core.FunctionLambda Lambda
v13 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Function"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"lambda"),
      fieldTerm :: Term
Core.fieldTerm = (Lambda -> Term
coreEncodeLambda Lambda
v13)}}))
  Core.FunctionPrimitive Name
v14 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Function"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"primitive"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName Name
v14)}}))

coreEncodeFunctionType :: (Core.FunctionType -> Core.Term)
coreEncodeFunctionType :: FunctionType -> Term
coreEncodeFunctionType FunctionType
ft = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.FunctionType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"domain"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (FunctionType -> Type
Core.functionTypeDomain FunctionType
ft))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"codomain"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (FunctionType -> Type
Core.functionTypeCodomain FunctionType
ft))}]}))

coreEncodeInjection :: (Core.Injection -> Core.Term)
coreEncodeInjection :: Injection -> Term
coreEncodeInjection Injection
i = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Injection"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (Injection -> Name
Core.injectionTypeName Injection
i))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"field"),
      fieldTerm :: Term
Core.fieldTerm = (Field -> Term
coreEncodeField (Injection -> Field
Core.injectionField Injection
i))}]}))

coreEncodeIntegerType :: (Core.IntegerType -> Core.Term)
coreEncodeIntegerType :: IntegerType -> Term
coreEncodeIntegerType IntegerType
x = case IntegerType
x of
  IntegerType
Core.IntegerTypeBigint -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"bigint"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeInt8 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int8"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeInt16 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int16"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeInt32 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int32"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeInt64 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int64"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeUint8 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint8"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeUint16 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint16"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeUint32 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint32"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  IntegerType
Core.IntegerTypeUint64 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint64"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))

coreEncodeIntegerValue :: (Core.IntegerValue -> Core.Term)
coreEncodeIntegerValue :: IntegerValue -> Term
coreEncodeIntegerValue IntegerValue
x = case IntegerValue
x of
  Core.IntegerValueBigint Integer
v24 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"bigint"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Integer -> IntegerValue
Core.IntegerValueBigint Integer
v24)))}}))
  Core.IntegerValueInt8 Int8
v25 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int8"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int8 -> IntegerValue
Core.IntegerValueInt8 Int8
v25)))}}))
  Core.IntegerValueInt16 Int16
v26 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int16"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int16 -> IntegerValue
Core.IntegerValueInt16 Int16
v26)))}}))
  Core.IntegerValueInt32 Int
v27 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int32"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueInt32 Int
v27)))}}))
  Core.IntegerValueInt64 Int64
v28 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"int64"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int64 -> IntegerValue
Core.IntegerValueInt64 Int64
v28)))}}))
  Core.IntegerValueUint8 Int16
v29 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint8"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int16 -> IntegerValue
Core.IntegerValueUint8 Int16
v29)))}}))
  Core.IntegerValueUint16 Int
v30 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint16"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueUint16 Int
v30)))}}))
  Core.IntegerValueUint32 Int64
v31 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint32"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int64 -> IntegerValue
Core.IntegerValueUint32 Int64
v31)))}}))
  Core.IntegerValueUint64 Integer
v32 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.IntegerValue"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"uint64"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Integer -> IntegerValue
Core.IntegerValueUint64 Integer
v32)))}}))

coreEncodeLambda :: (Core.Lambda -> Core.Term)
coreEncodeLambda :: Lambda -> Term
coreEncodeLambda Lambda
l = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Lambda"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"parameter"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (Lambda -> Name
Core.lambdaParameter Lambda
l))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"domain"),
      fieldTerm :: Term
Core.fieldTerm = (Maybe Term -> Term
Core.TermOptional ((Type -> Term) -> Maybe Type -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map Type -> Term
coreEncodeType (Lambda -> Maybe Type
Core.lambdaDomain Lambda
l)))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"body"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Lambda -> Term
Core.lambdaBody Lambda
l))}]}))

coreEncodeLambdaType :: (Core.LambdaType -> Core.Term)
coreEncodeLambdaType :: LambdaType -> Term
coreEncodeLambdaType LambdaType
lt = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.LambdaType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"parameter"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (LambdaType -> Name
Core.lambdaTypeParameter LambdaType
lt))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"body"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (LambdaType -> Type
Core.lambdaTypeBody LambdaType
lt))}]}))

coreEncodeLet :: (Core.Let -> Core.Term)
coreEncodeLet :: Let -> Term
coreEncodeLet Let
l = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Let"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"bindings"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((LetBinding -> Term) -> [LetBinding] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map LetBinding -> Term
coreEncodeLetBinding (Let -> [LetBinding]
Core.letBindings Let
l)))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"environment"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Let -> Term
Core.letEnvironment Let
l))}]}))

coreEncodeLetBinding :: (Core.LetBinding -> Core.Term)
coreEncodeLetBinding :: LetBinding -> Term
coreEncodeLetBinding LetBinding
b = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.LetBinding"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"name"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (LetBinding -> Name
Core.letBindingName LetBinding
b))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"term"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (LetBinding -> Term
Core.letBindingTerm LetBinding
b))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"type"),
      fieldTerm :: Term
Core.fieldTerm = (Maybe Term -> Term
Core.TermOptional ((TypeScheme -> Term) -> Maybe TypeScheme -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map TypeScheme -> Term
coreEncodeTypeScheme (LetBinding -> Maybe TypeScheme
Core.letBindingType LetBinding
b)))}]}))

coreEncodeLiteral :: (Core.Literal -> Core.Term)
coreEncodeLiteral :: Literal -> Term
coreEncodeLiteral Literal
x = case Literal
x of
  Core.LiteralBinary String
v33 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Literal"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"binary"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (String -> Literal
Core.LiteralBinary String
v33))}}))
  Core.LiteralBoolean Bool
v34 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Literal"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"boolean"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (Bool -> Literal
Core.LiteralBoolean Bool
v34))}}))
  Core.LiteralFloat FloatValue
v35 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Literal"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float"),
      fieldTerm :: Term
Core.fieldTerm = (FloatValue -> Term
coreEncodeFloatValue FloatValue
v35)}}))
  Core.LiteralInteger IntegerValue
v36 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Literal"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"integer"),
      fieldTerm :: Term
Core.fieldTerm = (IntegerValue -> Term
coreEncodeIntegerValue IntegerValue
v36)}}))
  Core.LiteralString String
v37 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Literal"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"string"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (String -> Literal
Core.LiteralString String
v37))}}))

coreEncodeLiteralType :: (Core.LiteralType -> Core.Term)
coreEncodeLiteralType :: LiteralType -> Term
coreEncodeLiteralType LiteralType
x = case LiteralType
x of
  LiteralType
Core.LiteralTypeBinary -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.LiteralType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"binary"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  LiteralType
Core.LiteralTypeBoolean -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.LiteralType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"boolean"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))
  Core.LiteralTypeFloat FloatType
v40 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.LiteralType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"float"),
      fieldTerm :: Term
Core.fieldTerm = (FloatType -> Term
coreEncodeFloatType FloatType
v40)}}))
  Core.LiteralTypeInteger IntegerType
v41 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.LiteralType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"integer"),
      fieldTerm :: Term
Core.fieldTerm = (IntegerType -> Term
coreEncodeIntegerType IntegerType
v41)}}))
  LiteralType
Core.LiteralTypeString -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.LiteralType"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"string"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
Core.TermRecord (Core.Record {
        recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Unit"),
        recordFields :: [Field]
Core.recordFields = []}))}}))

coreEncodeMapType :: (Core.MapType -> Core.Term)
coreEncodeMapType :: MapType -> Term
coreEncodeMapType MapType
mt = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.MapType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"keys"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (MapType -> Type
Core.mapTypeKeys MapType
mt))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"values"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (MapType -> Type
Core.mapTypeValues MapType
mt))}]}))

coreEncodeName :: (Core.Name -> Core.Term)
coreEncodeName :: Name -> Term
coreEncodeName Name
fn = (WrappedTerm -> Term
Core.TermWrap (Core.WrappedTerm {
  wrappedTermTypeName :: Name
Core.wrappedTermTypeName = (String -> Name
Core.Name String
"hydra/core.Name"),
  wrappedTermObject :: Term
Core.wrappedTermObject = (Literal -> Term
Core.TermLiteral (String -> Literal
Core.LiteralString (Name -> String
Core.unName Name
fn)))}))

coreEncodeOptionalCases :: (Core.OptionalCases -> Core.Term)
coreEncodeOptionalCases :: OptionalCases -> Term
coreEncodeOptionalCases OptionalCases
oc = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.OptionalCases"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"nothing"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (OptionalCases -> Term
Core.optionalCasesNothing OptionalCases
oc))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"just"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (OptionalCases -> Term
Core.optionalCasesJust OptionalCases
oc))}]}))

coreEncodeProjection :: (Core.Projection -> Core.Term)
coreEncodeProjection :: Projection -> Term
coreEncodeProjection Projection
p = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Projection"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (Projection -> Name
Core.projectionTypeName Projection
p))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"field"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (Projection -> Name
Core.projectionField Projection
p))}]}))

coreEncodeRecord :: (Core.Record -> Core.Term)
coreEncodeRecord :: Record -> Term
coreEncodeRecord Record
r = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Record"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (Record -> Name
Core.recordTypeName Record
r))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"fields"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Field -> Term) -> [Field] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Field -> Term
coreEncodeField (Record -> [Field]
Core.recordFields Record
r)))}]}))

coreEncodeRowType :: (Core.RowType -> Core.Term)
coreEncodeRowType :: RowType -> Term
coreEncodeRowType RowType
rt = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.RowType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (RowType -> Name
Core.rowTypeTypeName RowType
rt))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"fields"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((FieldType -> Term) -> [FieldType] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map FieldType -> Term
coreEncodeFieldType (RowType -> [FieldType]
Core.rowTypeFields RowType
rt)))}]}))

coreEncodeSum :: (Core.Sum -> Core.Term)
coreEncodeSum :: Sum -> Term
coreEncodeSum Sum
s = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.Sum"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"index"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueInt32 (Sum -> Int
Core.sumIndex Sum
s))))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"size"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueInt32 (Sum -> Int
Core.sumSize Sum
s))))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"term"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (Sum -> Term
Core.sumTerm Sum
s))}]}))

coreEncodeTerm :: (Core.Term -> Core.Term)
coreEncodeTerm :: Term -> Term
coreEncodeTerm Term
x = case Term
x of
  Core.TermAnnotated AnnotatedTerm
v43 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"annotated"),
      fieldTerm :: Term
Core.fieldTerm = (AnnotatedTerm -> Term
coreEncodeAnnotatedTerm AnnotatedTerm
v43)}}))
  Core.TermApplication Application
v44 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"application"),
      fieldTerm :: Term
Core.fieldTerm = (Application -> Term
coreEncodeApplication Application
v44)}}))
  Core.TermFunction Function
v45 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"function"),
      fieldTerm :: Term
Core.fieldTerm = (Function -> Term
coreEncodeFunction Function
v45)}}))
  Core.TermLet Let
v46 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"let"),
      fieldTerm :: Term
Core.fieldTerm = (Let -> Term
coreEncodeLet Let
v46)}}))
  Core.TermLiteral Literal
v47 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"literal"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
coreEncodeLiteral Literal
v47)}}))
  Core.TermList [Term]
v48 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"list"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Term -> Term) -> [Term] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Term -> Term
coreEncodeTerm [Term]
v48))}}))
  Core.TermOptional Maybe Term
v49 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"optional"),
      fieldTerm :: Term
Core.fieldTerm = (Maybe Term -> Term
Core.TermOptional ((Term -> Term) -> Maybe Term -> Maybe Term
forall a b. (a -> b) -> Maybe a -> Maybe b
Optionals.map Term -> Term
coreEncodeTerm Maybe Term
v49))}}))
  Core.TermProduct [Term]
v50 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"product"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Term -> Term) -> [Term] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Term -> Term
coreEncodeTerm [Term]
v50))}}))
  Core.TermRecord Record
v51 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"record"),
      fieldTerm :: Term
Core.fieldTerm = (Record -> Term
coreEncodeRecord Record
v51)}}))
  Core.TermSet Set Term
v52 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"set"),
      fieldTerm :: Term
Core.fieldTerm = (Set Term -> Term
Core.TermSet ((Term -> Term) -> Set Term -> Set Term
forall y x. Ord y => (x -> y) -> Set x -> Set y
Sets.map Term -> Term
coreEncodeTerm Set Term
v52))}}))
  Core.TermSum Sum
v53 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"sum"),
      fieldTerm :: Term
Core.fieldTerm = (Sum -> Term
coreEncodeSum Sum
v53)}}))
  Core.TermTypeAbstraction TypeAbstraction
v54 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeAbstraction"),
      fieldTerm :: Term
Core.fieldTerm = (TypeAbstraction -> Term
coreEncodeTypeAbstraction TypeAbstraction
v54)}}))
  Core.TermTypeApplication TypedTerm
v55 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeApplication"),
      fieldTerm :: Term
Core.fieldTerm = (TypedTerm -> Term
coreEncodeTypedTerm TypedTerm
v55)}}))
  Core.TermTyped TypedTerm
v56 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typed"),
      fieldTerm :: Term
Core.fieldTerm = (TypedTerm -> Term
coreEncodeTypedTerm TypedTerm
v56)}}))
  Core.TermUnion Injection
v57 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"union"),
      fieldTerm :: Term
Core.fieldTerm = (Injection -> Term
coreEncodeInjection Injection
v57)}}))
  Core.TermVariable Name
v58 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"variable"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName Name
v58)}}))
  Core.TermWrap WrappedTerm
v59 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Term"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"wrap"),
      fieldTerm :: Term
Core.fieldTerm = (WrappedTerm -> Term
coreEncodeWrappedTerm WrappedTerm
v59)}}))
  Term
_ -> (Literal -> Term
Core.TermLiteral (String -> Literal
Core.LiteralString String
"not implemented"))

coreEncodeTupleProjection :: (Core.TupleProjection -> Core.Term)
coreEncodeTupleProjection :: TupleProjection -> Term
coreEncodeTupleProjection TupleProjection
tp = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.TupleProjection"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"arity"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueInt32 (TupleProjection -> Int
Core.tupleProjectionArity TupleProjection
tp))))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"index"),
      fieldTerm :: Term
Core.fieldTerm = (Literal -> Term
Core.TermLiteral (IntegerValue -> Literal
Core.LiteralInteger (Int -> IntegerValue
Core.IntegerValueInt32 (TupleProjection -> Int
Core.tupleProjectionIndex TupleProjection
tp))))}]}))

coreEncodeType :: (Core.Type -> Core.Term)
coreEncodeType :: Type -> Term
coreEncodeType Type
x = case Type
x of
  Core.TypeAnnotated AnnotatedType
v60 -> (AnnotatedTerm -> Term
Core.TermAnnotated (Core.AnnotatedTerm {
    annotatedTermSubject :: Term
Core.annotatedTermSubject = (Type -> Term
coreEncodeType (AnnotatedType -> Type
Core.annotatedTypeSubject AnnotatedType
v60)),
    annotatedTermAnnotation :: Map Name Term
Core.annotatedTermAnnotation = (AnnotatedType -> Map Name Term
Core.annotatedTypeAnnotation AnnotatedType
v60)}))
  Core.TypeApplication ApplicationType
v61 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"application"),
      fieldTerm :: Term
Core.fieldTerm = (ApplicationType -> Term
coreEncodeApplicationType ApplicationType
v61)}}))
  Core.TypeFunction FunctionType
v62 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"function"),
      fieldTerm :: Term
Core.fieldTerm = (FunctionType -> Term
coreEncodeFunctionType FunctionType
v62)}}))
  Core.TypeLambda LambdaType
v63 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"lambda"),
      fieldTerm :: Term
Core.fieldTerm = (LambdaType -> Term
coreEncodeLambdaType LambdaType
v63)}}))
  Core.TypeList Type
v64 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"list"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType Type
v64)}}))
  Core.TypeLiteral LiteralType
v65 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"literal"),
      fieldTerm :: Term
Core.fieldTerm = (LiteralType -> Term
coreEncodeLiteralType LiteralType
v65)}}))
  Core.TypeMap MapType
v66 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"map"),
      fieldTerm :: Term
Core.fieldTerm = (MapType -> Term
coreEncodeMapType MapType
v66)}}))
  Core.TypeOptional Type
v67 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"optional"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType Type
v67)}}))
  Core.TypeProduct [Type]
v68 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"product"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Type -> Term) -> [Type] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Type -> Term
coreEncodeType [Type]
v68))}}))
  Core.TypeRecord RowType
v69 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"record"),
      fieldTerm :: Term
Core.fieldTerm = (RowType -> Term
coreEncodeRowType RowType
v69)}}))
  Core.TypeSet Type
v70 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"set"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType Type
v70)}}))
  Core.TypeSum [Type]
v71 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"sum"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Type -> Term) -> [Type] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Type -> Term
coreEncodeType [Type]
v71))}}))
  Core.TypeUnion RowType
v72 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"union"),
      fieldTerm :: Term
Core.fieldTerm = (RowType -> Term
coreEncodeRowType RowType
v72)}}))
  Core.TypeVariable Name
v73 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"variable"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName Name
v73)}}))
  Core.TypeWrap WrappedType
v74 -> (Injection -> Term
Core.TermUnion (Core.Injection {
    injectionTypeName :: Name
Core.injectionTypeName = (String -> Name
Core.Name String
"hydra/core.Type"),
    injectionField :: Field
Core.injectionField = Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"wrap"),
      fieldTerm :: Term
Core.fieldTerm = (WrappedType -> Term
coreEncodeWrappedType WrappedType
v74)}}))

coreEncodeTypeAbstraction :: (Core.TypeAbstraction -> Core.Term)
coreEncodeTypeAbstraction :: TypeAbstraction -> Term
coreEncodeTypeAbstraction TypeAbstraction
l = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.TypeAbstraction"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"parameter"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (TypeAbstraction -> Name
Core.typeAbstractionParameter TypeAbstraction
l))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"body"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (TypeAbstraction -> Term
Core.typeAbstractionBody TypeAbstraction
l))}]}))

coreEncodeTypeScheme :: (Core.TypeScheme -> Core.Term)
coreEncodeTypeScheme :: TypeScheme -> Term
coreEncodeTypeScheme TypeScheme
ts = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.TypeScheme"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"variables"),
      fieldTerm :: Term
Core.fieldTerm = ([Term] -> Term
Core.TermList ((Name -> Term) -> [Name] -> [Term]
forall a b. (a -> b) -> [a] -> [b]
Lists.map Name -> Term
coreEncodeName (TypeScheme -> [Name]
Core.typeSchemeVariables TypeScheme
ts)))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"type"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (TypeScheme -> Type
Core.typeSchemeType TypeScheme
ts))}]}))

coreEncodeTypedTerm :: (Core.TypedTerm -> Core.Term)
coreEncodeTypedTerm :: TypedTerm -> Term
coreEncodeTypedTerm TypedTerm
tt = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.TypedTerm"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"term"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (TypedTerm -> Term
Core.typedTermTerm TypedTerm
tt))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"type"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (TypedTerm -> Type
Core.typedTermType TypedTerm
tt))}]}))

coreEncodeWrappedTerm :: (Core.WrappedTerm -> Core.Term)
coreEncodeWrappedTerm :: WrappedTerm -> Term
coreEncodeWrappedTerm WrappedTerm
n = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.WrappedTerm"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (WrappedTerm -> Name
Core.wrappedTermTypeName WrappedTerm
n))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"object"),
      fieldTerm :: Term
Core.fieldTerm = (Term -> Term
coreEncodeTerm (WrappedTerm -> Term
Core.wrappedTermObject WrappedTerm
n))}]}))

coreEncodeWrappedType :: (Core.WrappedType -> Core.Term)
coreEncodeWrappedType :: WrappedType -> Term
coreEncodeWrappedType WrappedType
nt = (Record -> Term
Core.TermRecord (Core.Record {
  recordTypeName :: Name
Core.recordTypeName = (String -> Name
Core.Name String
"hydra/core.WrappedType"),
  recordFields :: [Field]
Core.recordFields = [
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"typeName"),
      fieldTerm :: Term
Core.fieldTerm = (Name -> Term
coreEncodeName (WrappedType -> Name
Core.wrappedTypeTypeName WrappedType
nt))},
    Core.Field {
      fieldName :: Name
Core.fieldName = (String -> Name
Core.Name String
"object"),
      fieldTerm :: Term
Core.fieldTerm = (Type -> Term
coreEncodeType (WrappedType -> Type
Core.wrappedTypeObject WrappedType
nt))}]}))