hydra-kernel-0.17.0: src/main/haskell/Hydra/Encode/Core.hs

-- Note: this is an automatically generated file. Do not edit.

-- | Term encoders for hydra.core

module Hydra.Encode.Core where

import qualified Hydra.Core as Core
import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | Encoder for hydra.core.AnnotatedTerm
annotatedTerm :: Core.AnnotatedTerm -> Core.Term
annotatedTerm x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.annotatedTermBody x))},
        Core.Field {
          Core.fieldName = (Core.Name "annotation"),
          Core.fieldTerm = (term (Core.annotatedTermAnnotation x))}]})

-- | Encoder for hydra.core.AnnotatedType
annotatedType :: Core.AnnotatedType -> Core.Term
annotatedType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (type_ (Core.annotatedTypeBody x))},
        Core.Field {
          Core.fieldName = (Core.Name "annotation"),
          Core.fieldTerm = (term (Core.annotatedTypeAnnotation x))}]})

-- | Encoder for hydra.core.Application
application :: Core.Application -> Core.Term
application x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Application"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "function"),
          Core.fieldTerm = (term (Core.applicationFunction x))},
        Core.Field {
          Core.fieldName = (Core.Name "argument"),
          Core.fieldTerm = (term (Core.applicationArgument x))}]})

-- | Encoder for hydra.core.ApplicationType
applicationType :: Core.ApplicationType -> Core.Term
applicationType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "function"),
          Core.fieldTerm = (type_ (Core.applicationTypeFunction x))},
        Core.Field {
          Core.fieldName = (Core.Name "argument"),
          Core.fieldTerm = (type_ (Core.applicationTypeArgument x))}]})

-- | Encoder for hydra.core.Binding
binding :: Core.Binding -> Core.Term
binding x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Binding"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (name (Core.bindingName x))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (term (Core.bindingTerm x))},
        Core.Field {
          Core.fieldName = (Core.Name "typeScheme"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map typeScheme opt)) (Core.bindingTypeScheme x))}]})

-- | Encoder for hydra.core.CaseAlternative
caseAlternative :: Core.CaseAlternative -> Core.Term
caseAlternative x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (name (Core.caseAlternativeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "handler"),
          Core.fieldTerm = (term (Core.caseAlternativeHandler x))}]})

-- | Encoder for hydra.core.CaseStatement
caseStatement :: Core.CaseStatement -> Core.Term
caseStatement x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeName"),
          Core.fieldTerm = (name (Core.caseStatementTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "default"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map term opt)) (Core.caseStatementDefault x))},
        Core.Field {
          Core.fieldName = (Core.Name "cases"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map caseAlternative xs)) (Core.caseStatementCases x))}]})

-- | Encoder for hydra.core.EitherType
eitherType :: Core.EitherType -> Core.Term
eitherType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.EitherType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (type_ (Core.eitherTypeLeft x))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (type_ (Core.eitherTypeRight x))}]})

-- | Encoder for hydra.core.Field
field :: Core.Field -> Core.Term
field x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Field"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (name (Core.fieldName x))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (term (Core.fieldTerm x))}]})

-- | Encoder for hydra.core.FieldType
fieldType :: Core.FieldType -> Core.Term
fieldType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.FieldType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (name (Core.fieldTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (type_ (Core.fieldTypeType x))}]})

-- | Encoder for hydra.core.FloatType
floatType :: Core.FloatType -> Core.Term
floatType x =
    case x of
      Core.FloatTypeFloat32 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float32"),
          Core.fieldTerm = Core.TermUnit}})
      Core.FloatTypeFloat64 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float64"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.core.FloatValue
floatValue :: Core.FloatValue -> Core.Term
floatValue x =
    case x of
      Core.FloatValueFloat32 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float32"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v0)))}})
      Core.FloatValueFloat64 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float64"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v0)))}})

-- | Encoder for hydra.core.ForallType
forallType :: Core.ForallType -> Core.Term
forallType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.ForallType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (name (Core.forallTypeParameter x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (type_ (Core.forallTypeBody x))}]})

-- | Encoder for hydra.core.FunctionType
functionType :: Core.FunctionType -> Core.Term
functionType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "domain"),
          Core.fieldTerm = (type_ (Core.functionTypeDomain x))},
        Core.Field {
          Core.fieldName = (Core.Name "codomain"),
          Core.fieldTerm = (type_ (Core.functionTypeCodomain x))}]})

-- | Encoder for hydra.core.Injection
injection :: Core.Injection -> Core.Term
injection x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Injection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeName"),
          Core.fieldTerm = (name (Core.injectionTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "field"),
          Core.fieldTerm = (field (Core.injectionField x))}]})

-- | Encoder for hydra.core.IntegerType
integerType :: Core.IntegerType -> Core.Term
integerType x =
    case x of
      Core.IntegerTypeBigint -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "bigint"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeInt8 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int8"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeInt16 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int16"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeInt32 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int32"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeInt64 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int64"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeUint8 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint8"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeUint16 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint16"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeUint32 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint32"),
          Core.fieldTerm = Core.TermUnit}})
      Core.IntegerTypeUint64 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint64"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.core.IntegerValue
integerValue :: Core.IntegerValue -> Core.Term
integerValue x =
    case x of
      Core.IntegerValueBigint v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "bigint"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v0)))}})
      Core.IntegerValueInt8 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int8"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt8 v0)))}})
      Core.IntegerValueInt16 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int16"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt16 v0)))}})
      Core.IntegerValueInt32 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int32"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Core.IntegerValueInt64 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "int64"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v0)))}})
      Core.IntegerValueUint8 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint8"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint8 v0)))}})
      Core.IntegerValueUint16 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint16"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint16 v0)))}})
      Core.IntegerValueUint32 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint32"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v0)))}})
      Core.IntegerValueUint64 v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "uint64"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v0)))}})

-- | Encoder for hydra.core.Lambda
lambda :: Core.Lambda -> Core.Term
lambda x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (name (Core.lambdaParameter x))},
        Core.Field {
          Core.fieldName = (Core.Name "domain"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map type_ opt)) (Core.lambdaDomain x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.lambdaBody x))}]})

-- | Encoder for hydra.core.Let
let_ :: Core.Let -> Core.Term
let_ x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Let"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "bindings"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map binding xs)) (Core.letBindings x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.letBody x))}]})

-- | Encoder for hydra.core.Literal
literal :: Core.Literal -> Core.Term
literal x =
    case x of
      Core.LiteralBinary v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "binary"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralBinary v0))}})
      Core.LiteralBoolean v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "boolean"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}})
      Core.LiteralDecimal v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "decimal"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralDecimal v0))}})
      Core.LiteralFloat v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float"),
          Core.fieldTerm = (floatValue v0)}})
      Core.LiteralInteger v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "integer"),
          Core.fieldTerm = (integerValue v0)}})
      Core.LiteralString v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "string"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})

-- | Encoder for hydra.core.LiteralType
literalType :: Core.LiteralType -> Core.Term
literalType x =
    case x of
      Core.LiteralTypeBinary -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "binary"),
          Core.fieldTerm = Core.TermUnit}})
      Core.LiteralTypeBoolean -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "boolean"),
          Core.fieldTerm = Core.TermUnit}})
      Core.LiteralTypeDecimal -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "decimal"),
          Core.fieldTerm = Core.TermUnit}})
      Core.LiteralTypeFloat v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "float"),
          Core.fieldTerm = (floatType v0)}})
      Core.LiteralTypeInteger v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "integer"),
          Core.fieldTerm = (integerType v0)}})
      Core.LiteralTypeString -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "string"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.core.MapType
mapType :: Core.MapType -> Core.Term
mapType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.MapType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "keys"),
          Core.fieldTerm = (type_ (Core.mapTypeKeys x))},
        Core.Field {
          Core.fieldName = (Core.Name "values"),
          Core.fieldTerm = (type_ (Core.mapTypeValues x))}]})

-- | Encoder for hydra.core.Name
name :: Core.Name -> Core.Term
name x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Core.unName x))})

-- | Encoder for hydra.core.PairType
pairType :: Core.PairType -> Core.Term
pairType x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.PairType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "first"),
          Core.fieldTerm = (type_ (Core.pairTypeFirst x))},
        Core.Field {
          Core.fieldName = (Core.Name "second"),
          Core.fieldTerm = (type_ (Core.pairTypeSecond x))}]})

-- | Encoder for hydra.core.Projection
projection :: Core.Projection -> Core.Term
projection x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Projection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeName"),
          Core.fieldTerm = (name (Core.projectionTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "fieldName"),
          Core.fieldTerm = (name (Core.projectionFieldName x))}]})

-- | Encoder for hydra.core.Record
record :: Core.Record -> Core.Term
record x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.Record"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeName"),
          Core.fieldTerm = (name (Core.recordTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "fields"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map field xs)) (Core.recordFields x))}]})

-- | Encoder for hydra.core.Term
term :: Core.Term -> Core.Term
term x =
    case x of
      Core.TermAnnotated v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotated"),
          Core.fieldTerm = (annotatedTerm v0)}})
      Core.TermApplication v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "application"),
          Core.fieldTerm = (application v0)}})
      Core.TermCases v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "cases"),
          Core.fieldTerm = (caseStatement v0)}})
      Core.TermEither v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "either"),
          Core.fieldTerm = (Core.TermEither (Eithers.bimap term term v0))}})
      Core.TermInject v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "inject"),
          Core.fieldTerm = (injection v0)}})
      Core.TermLambda v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "lambda"),
          Core.fieldTerm = (lambda v0)}})
      Core.TermLet v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "let"),
          Core.fieldTerm = (let_ v0)}})
      Core.TermList v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "list"),
          Core.fieldTerm = (Core.TermList (Lists.map term v0))}})
      Core.TermLiteral v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "literal"),
          Core.fieldTerm = (literal v0)}})
      Core.TermMap v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "map"),
          Core.fieldTerm = (Core.TermMap (Maps.bimap term term v0))}})
      Core.TermOptional v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "optional"),
          Core.fieldTerm = (Core.TermOptional (Optionals.map term v0))}})
      Core.TermPair v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pair"),
          Core.fieldTerm = (Core.TermPair (Pairs.bimap term term v0))}})
      Core.TermProject v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "project"),
          Core.fieldTerm = (projection v0)}})
      Core.TermRecord v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "record"),
          Core.fieldTerm = (record v0)}})
      Core.TermSet v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (Core.TermSet (Sets.map term v0))}})
      Core.TermTypeApplication v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeApplication"),
          Core.fieldTerm = (typeApplicationTerm v0)}})
      Core.TermTypeLambda v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeLambda"),
          Core.fieldTerm = (typeLambda v0)}})
      Core.TermUnit -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unit"),
          Core.fieldTerm = Core.TermUnit}})
      Core.TermUnwrap v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unwrap"),
          Core.fieldTerm = (name v0)}})
      Core.TermVariable v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (name v0)}})
      Core.TermWrap v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Term"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "wrap"),
          Core.fieldTerm = (wrappedTerm v0)}})

-- | Encoder for hydra.core.Type
type_ :: Core.Type -> Core.Term
type_ x =
    case x of
      Core.TypeAnnotated v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotated"),
          Core.fieldTerm = (annotatedType v0)}})
      Core.TypeApplication v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "application"),
          Core.fieldTerm = (applicationType v0)}})
      Core.TypeEffect v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "effect"),
          Core.fieldTerm = (type_ v0)}})
      Core.TypeEither v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "either"),
          Core.fieldTerm = (eitherType v0)}})
      Core.TypeForall v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "forall"),
          Core.fieldTerm = (forallType v0)}})
      Core.TypeFunction v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "function"),
          Core.fieldTerm = (functionType v0)}})
      Core.TypeList v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "list"),
          Core.fieldTerm = (type_ v0)}})
      Core.TypeLiteral v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "literal"),
          Core.fieldTerm = (literalType v0)}})
      Core.TypeMap v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "map"),
          Core.fieldTerm = (mapType v0)}})
      Core.TypeOptional v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "optional"),
          Core.fieldTerm = (type_ v0)}})
      Core.TypePair v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pair"),
          Core.fieldTerm = (pairType v0)}})
      Core.TypeRecord v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "record"),
          Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}})
      Core.TypeSet v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (type_ v0)}})
      Core.TypeUnion v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "union"),
          Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}})
      Core.TypeUnit -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unit"),
          Core.fieldTerm = Core.TermUnit}})
      Core.TypeVariable v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (name v0)}})
      Core.TypeVoid -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "void"),
          Core.fieldTerm = Core.TermUnit}})
      Core.TypeWrap v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.Type"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "wrap"),
          Core.fieldTerm = (type_ v0)}})

-- | Encoder for hydra.core.TypeApplicationTerm
typeApplicationTerm :: Core.TypeApplicationTerm -> Core.Term
typeApplicationTerm x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.typeApplicationTermBody x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (type_ (Core.typeApplicationTermType x))}]})

-- | Encoder for hydra.core.TypeClassConstraint
typeClassConstraint :: Core.TypeClassConstraint -> Core.Term
typeClassConstraint x =
    case x of
      Core.TypeClassConstraintSimple v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.core.TypeClassConstraint"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "simple"),
          Core.fieldTerm = (name v0)}})

-- | Encoder for hydra.core.TypeLambda
typeLambda :: Core.TypeLambda -> Core.Term
typeLambda x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (name (Core.typeLambdaParameter x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.typeLambdaBody x))}]})

-- | Encoder for hydra.core.TypeScheme
typeScheme :: Core.TypeScheme -> Core.Term
typeScheme x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variables"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map name xs)) (Core.typeSchemeVariables x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (type_ (Core.typeSchemeBody x))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\m -> Core.TermMap (Maps.bimap name typeVariableConstraints m)) opt)) (Core.typeSchemeConstraints x))}]})

-- | Encoder for hydra.core.TypeVariableConstraints
typeVariableConstraints :: Core.TypeVariableConstraints -> Core.Term
typeVariableConstraints x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "classes"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeClassConstraint xs)) (Core.typeVariableConstraintsClasses x))}]})

-- | Encoder for hydra.core.WrappedTerm
wrappedTerm :: Core.WrappedTerm -> Core.Term
wrappedTerm x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeName"),
          Core.fieldTerm = (name (Core.wrappedTermTypeName x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (term (Core.wrappedTermBody x))}]})