hydra-kernel-0.18.0: src/main/haskell/Hydra/Core/Dsl/Model.hs

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

-- | DSL functions for hydra.core.model

module Hydra.Core.Dsl.Model where

import qualified Hydra.Core.Decode.Model as DecodeModel
import qualified Hydra.Core.Encode.Model as EncodeModel
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.ByteString as B
import qualified Data.Int as I
import qualified Data.Map as M
import qualified Data.Set as S

-- | DSL constructor for hydra.core.model.AnnotatedTerm
annotatedTerm :: Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.AnnotatedTerm
annotatedTerm body annotation =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Typed.unTypedTerm annotation)}]}))

-- | DSL name token for hydra.core.model.AnnotatedTerm
annotatedTermAnnotatedTerm :: Typed.TypedName Model.AnnotatedTerm
annotatedTermAnnotatedTerm = Typed.TypedName (Model.Name "hydra.core.model.AnnotatedTerm")

-- | DSL accessor for the annotation field of hydra.core.model.AnnotatedTerm
annotatedTermAnnotation :: Typed.TypedTerm Model.AnnotatedTerm -> Typed.TypedTerm Model.Term
annotatedTermAnnotation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
        Model.projectionFieldName = (Model.Name "annotation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.core.model.AnnotatedTerm
annotatedTermBody :: Typed.TypedTerm Model.AnnotatedTerm -> Typed.TypedTerm Model.Term
annotatedTermBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the annotation field of hydra.core.model.AnnotatedTerm
annotatedTermWithAnnotation :: Typed.TypedTerm Model.AnnotatedTerm -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.AnnotatedTerm
annotatedTermWithAnnotation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the body field of hydra.core.model.AnnotatedTerm
annotatedTermWithBody :: Typed.TypedTerm Model.AnnotatedTerm -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.AnnotatedTerm
annotatedTermWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedTerm"),
              Model.projectionFieldName = (Model.Name "annotation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.AnnotatedType
annotatedType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.AnnotatedType
annotatedType body annotation =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Typed.unTypedTerm annotation)}]}))

-- | DSL name token for hydra.core.model.AnnotatedType
annotatedTypeAnnotatedType :: Typed.TypedName Model.AnnotatedType
annotatedTypeAnnotatedType = Typed.TypedName (Model.Name "hydra.core.model.AnnotatedType")

-- | DSL accessor for the annotation field of hydra.core.model.AnnotatedType
annotatedTypeAnnotation :: Typed.TypedTerm Model.AnnotatedType -> Typed.TypedTerm Model.Term
annotatedTypeAnnotation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
        Model.projectionFieldName = (Model.Name "annotation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.core.model.AnnotatedType
annotatedTypeBody :: Typed.TypedTerm Model.AnnotatedType -> Typed.TypedTerm Model.Type
annotatedTypeBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the annotation field of hydra.core.model.AnnotatedType
annotatedTypeWithAnnotation :: Typed.TypedTerm Model.AnnotatedType -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.AnnotatedType
annotatedTypeWithAnnotation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the body field of hydra.core.model.AnnotatedType
annotatedTypeWithBody :: Typed.TypedTerm Model.AnnotatedType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.AnnotatedType
annotatedTypeWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "annotation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.AnnotatedType"),
              Model.projectionFieldName = (Model.Name "annotation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.Application
application :: Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Application
application function argument =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Application"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Typed.unTypedTerm argument)}]}))

-- | DSL name token for hydra.core.model.Application
applicationApplication :: Typed.TypedName Model.Application
applicationApplication = Typed.TypedName (Model.Name "hydra.core.model.Application")

-- | DSL accessor for the argument field of hydra.core.model.Application
applicationArgument :: Typed.TypedTerm Model.Application -> Typed.TypedTerm Model.Term
applicationArgument x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Application"),
        Model.projectionFieldName = (Model.Name "argument")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the function field of hydra.core.model.Application
applicationFunction :: Typed.TypedTerm Model.Application -> Typed.TypedTerm Model.Term
applicationFunction x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Application"),
        Model.projectionFieldName = (Model.Name "function")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.core.model.ApplicationType
applicationType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.ApplicationType
applicationType function argument =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ApplicationType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm function)},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Typed.unTypedTerm argument)}]}))

-- | DSL name token for hydra.core.model.ApplicationType
applicationTypeApplicationType :: Typed.TypedName Model.ApplicationType
applicationTypeApplicationType = Typed.TypedName (Model.Name "hydra.core.model.ApplicationType")

-- | DSL accessor for the argument field of hydra.core.model.ApplicationType
applicationTypeArgument :: Typed.TypedTerm Model.ApplicationType -> Typed.TypedTerm Model.Type
applicationTypeArgument x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.ApplicationType"),
        Model.projectionFieldName = (Model.Name "argument")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the function field of hydra.core.model.ApplicationType
applicationTypeFunction :: Typed.TypedTerm Model.ApplicationType -> Typed.TypedTerm Model.Type
applicationTypeFunction x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.ApplicationType"),
        Model.projectionFieldName = (Model.Name "function")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the argument field of hydra.core.model.ApplicationType
applicationTypeWithArgument :: Typed.TypedTerm Model.ApplicationType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.ApplicationType
applicationTypeWithArgument original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ApplicationType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.ApplicationType"),
              Model.projectionFieldName = (Model.Name "function")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the function field of hydra.core.model.ApplicationType
applicationTypeWithFunction :: Typed.TypedTerm Model.ApplicationType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.ApplicationType
applicationTypeWithFunction original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ApplicationType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.ApplicationType"),
              Model.projectionFieldName = (Model.Name "argument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the argument field of hydra.core.model.Application
applicationWithArgument :: Typed.TypedTerm Model.Application -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Application
applicationWithArgument original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Application"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Application"),
              Model.projectionFieldName = (Model.Name "function")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the function field of hydra.core.model.Application
applicationWithFunction :: Typed.TypedTerm Model.Application -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Application
applicationWithFunction original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Application"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "function"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "argument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Application"),
              Model.projectionFieldName = (Model.Name "argument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.Binding
binding :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term -> Typed.TypedTerm (Maybe Model.TypeScheme) -> Typed.TypedTerm Model.Binding
binding name term typeScheme =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Binding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm term)},
        Model.Field {
          Model.fieldName = (Model.Name "typeScheme"),
          Model.fieldTerm = (Typed.unTypedTerm typeScheme)}]}))

-- | DSL name token for hydra.core.model.Binding
bindingBinding :: Typed.TypedName Model.Binding
bindingBinding = Typed.TypedName (Model.Name "hydra.core.model.Binding")

-- | DSL accessor for the name field of hydra.core.model.Binding
bindingName :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm Model.Name
bindingName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.core.model.Binding
bindingTerm :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm Model.Term
bindingTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
        Model.projectionFieldName = (Model.Name "term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeScheme field of hydra.core.model.Binding
bindingTypeScheme :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm (Maybe Model.TypeScheme)
bindingTypeScheme x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
        Model.projectionFieldName = (Model.Name "typeScheme")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.core.model.Binding
bindingWithName :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Binding
bindingWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Binding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeScheme"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "typeScheme")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the term field of hydra.core.model.Binding
bindingWithTerm :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Binding
bindingWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Binding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeScheme"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "typeScheme")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeScheme field of hydra.core.model.Binding
bindingWithTypeScheme :: Typed.TypedTerm Model.Binding -> Typed.TypedTerm (Maybe Model.TypeScheme) -> Typed.TypedTerm Model.Binding
bindingWithTypeScheme original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Binding"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Binding"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeScheme"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.core.model.CaseAlternative
caseAlternative :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.CaseAlternative
caseAlternative name handler =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "handler"),
          Model.fieldTerm = (Typed.unTypedTerm handler)}]}))

-- | DSL name token for hydra.core.model.CaseAlternative
caseAlternativeCaseAlternative :: Typed.TypedName Model.CaseAlternative
caseAlternativeCaseAlternative = Typed.TypedName (Model.Name "hydra.core.model.CaseAlternative")

-- | DSL accessor for the handler field of hydra.core.model.CaseAlternative
caseAlternativeHandler :: Typed.TypedTerm Model.CaseAlternative -> Typed.TypedTerm Model.Term
caseAlternativeHandler x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
        Model.projectionFieldName = (Model.Name "handler")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.core.model.CaseAlternative
caseAlternativeName :: Typed.TypedTerm Model.CaseAlternative -> Typed.TypedTerm Model.Name
caseAlternativeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the handler field of hydra.core.model.CaseAlternative
caseAlternativeWithHandler :: Typed.TypedTerm Model.CaseAlternative -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.CaseAlternative
caseAlternativeWithHandler original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "handler"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.core.model.CaseAlternative
caseAlternativeWithName :: Typed.TypedTerm Model.CaseAlternative -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.CaseAlternative
caseAlternativeWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "handler"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseAlternative"),
              Model.projectionFieldName = (Model.Name "handler")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.CaseStatement
caseStatement :: Typed.TypedTerm Model.Name -> Typed.TypedTerm (Maybe Model.Term) -> Typed.TypedTerm [Model.CaseAlternative] -> Typed.TypedTerm Model.CaseStatement
caseStatement typeName default_ cases =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm typeName)},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm default_)},
        Model.Field {
          Model.fieldName = (Model.Name "cases"),
          Model.fieldTerm = (Typed.unTypedTerm cases)}]}))

-- | DSL name token for hydra.core.model.CaseStatement
caseStatementCaseStatement :: Typed.TypedName Model.CaseStatement
caseStatementCaseStatement = Typed.TypedName (Model.Name "hydra.core.model.CaseStatement")

-- | DSL accessor for the cases field of hydra.core.model.CaseStatement
caseStatementCases :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm [Model.CaseAlternative]
caseStatementCases x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
        Model.projectionFieldName = (Model.Name "cases")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the default field of hydra.core.model.CaseStatement
caseStatementDefault :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm (Maybe Model.Term)
caseStatementDefault x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
        Model.projectionFieldName = (Model.Name "default")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeName field of hydra.core.model.CaseStatement
caseStatementTypeName :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm Model.Name
caseStatementTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
        Model.projectionFieldName = (Model.Name "typeName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the cases field of hydra.core.model.CaseStatement
caseStatementWithCases :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm [Model.CaseAlternative] -> Typed.TypedTerm Model.CaseStatement
caseStatementWithCases original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cases"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the default field of hydra.core.model.CaseStatement
caseStatementWithDefault :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm (Maybe Model.Term) -> Typed.TypedTerm Model.CaseStatement
caseStatementWithDefault original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "cases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "cases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeName field of hydra.core.model.CaseStatement
caseStatementWithTypeName :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.CaseStatement
caseStatementWithTypeName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.CaseStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "cases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.CaseStatement"),
              Model.projectionFieldName = (Model.Name "cases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.EitherType
eitherType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.EitherType
eitherType left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.EitherType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.core.model.EitherType
eitherTypeEitherType :: Typed.TypedName Model.EitherType
eitherTypeEitherType = Typed.TypedName (Model.Name "hydra.core.model.EitherType")

-- | DSL accessor for the left field of hydra.core.model.EitherType
eitherTypeLeft :: Typed.TypedTerm Model.EitherType -> Typed.TypedTerm Model.Type
eitherTypeLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.EitherType"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.core.model.EitherType
eitherTypeRight :: Typed.TypedTerm Model.EitherType -> Typed.TypedTerm Model.Type
eitherTypeRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.EitherType"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.core.model.EitherType
eitherTypeWithLeft :: Typed.TypedTerm Model.EitherType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.EitherType
eitherTypeWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.EitherType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.EitherType"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.core.model.EitherType
eitherTypeWithRight :: Typed.TypedTerm Model.EitherType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.EitherType
eitherTypeWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.EitherType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.EitherType"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.core.model.Field
field :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Field
field name term =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm term)}]}))

-- | DSL name token for hydra.core.model.Field
fieldField :: Typed.TypedName Model.Field
fieldField = Typed.TypedName (Model.Name "hydra.core.model.Field")

-- | DSL accessor for the name field of hydra.core.model.Field
fieldName :: Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Name
fieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Field"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.core.model.Field
fieldTerm :: Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Term
fieldTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Field"),
        Model.projectionFieldName = (Model.Name "term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.core.model.FieldType
fieldType :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.FieldType
fieldType name type_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FieldType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL name token for hydra.core.model.FieldType
fieldTypeFieldType :: Typed.TypedName Model.FieldType
fieldTypeFieldType = Typed.TypedName (Model.Name "hydra.core.model.FieldType")

-- | DSL accessor for the name field of hydra.core.model.FieldType
fieldTypeName :: Typed.TypedTerm Model.FieldType -> Typed.TypedTerm Model.Name
fieldTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.FieldType"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.core.model.FieldType
fieldTypeType :: Typed.TypedTerm Model.FieldType -> Typed.TypedTerm Model.Type
fieldTypeType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.FieldType"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.core.model.FieldType
fieldTypeWithName :: Typed.TypedTerm Model.FieldType -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.FieldType
fieldTypeWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FieldType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.FieldType"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.core.model.FieldType
fieldTypeWithType :: Typed.TypedTerm Model.FieldType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.FieldType
fieldTypeWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FieldType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.FieldType"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.core.model.Field
fieldWithName :: Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Field
fieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Field"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the term field of hydra.core.model.Field
fieldWithTerm :: Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Field
fieldWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the float32 variant of hydra.core.model.FloatType
floatTypeFloat32 :: Typed.TypedTerm Model.FloatType
floatTypeFloat32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.FloatType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float64 variant of hydra.core.model.FloatType
floatTypeFloat64 :: Typed.TypedTerm Model.FloatType
floatTypeFloat64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.FloatType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.core.model.FloatType
floatTypeFloatType :: Typed.TypedName Model.FloatType
floatTypeFloatType = Typed.TypedName (Model.Name "hydra.core.model.FloatType")

-- | DSL injection for the float32 variant of hydra.core.model.FloatValue
floatValueFloat32 :: Typed.TypedTerm Float -> Typed.TypedTerm Model.FloatValue
floatValueFloat32 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.FloatValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float32"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the float64 variant of hydra.core.model.FloatValue
floatValueFloat64 :: Typed.TypedTerm Double -> Typed.TypedTerm Model.FloatValue
floatValueFloat64 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.FloatValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float64"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.FloatValue
floatValueFloatValue :: Typed.TypedName Model.FloatValue
floatValueFloatValue = Typed.TypedName (Model.Name "hydra.core.model.FloatValue")

-- | DSL constructor for hydra.core.model.ForallType
forallType :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.ForallType
forallType parameter body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ForallType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.core.model.ForallType
forallTypeBody :: Typed.TypedTerm Model.ForallType -> Typed.TypedTerm Model.Type
forallTypeBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.ForallType"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.ForallType
forallTypeForallType :: Typed.TypedName Model.ForallType
forallTypeForallType = Typed.TypedName (Model.Name "hydra.core.model.ForallType")

-- | DSL accessor for the parameter field of hydra.core.model.ForallType
forallTypeParameter :: Typed.TypedTerm Model.ForallType -> Typed.TypedTerm Model.Name
forallTypeParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.ForallType"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.core.model.ForallType
forallTypeWithBody :: Typed.TypedTerm Model.ForallType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.ForallType
forallTypeWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ForallType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.ForallType"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the parameter field of hydra.core.model.ForallType
forallTypeWithParameter :: Typed.TypedTerm Model.ForallType -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.ForallType
forallTypeWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.ForallType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.ForallType"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.FunctionType
functionType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.FunctionType
functionType domain codomain =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FunctionType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Typed.unTypedTerm domain)},
        Model.Field {
          Model.fieldName = (Model.Name "codomain"),
          Model.fieldTerm = (Typed.unTypedTerm codomain)}]}))

-- | DSL accessor for the codomain field of hydra.core.model.FunctionType
functionTypeCodomain :: Typed.TypedTerm Model.FunctionType -> Typed.TypedTerm Model.Type
functionTypeCodomain x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.FunctionType"),
        Model.projectionFieldName = (Model.Name "codomain")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the domain field of hydra.core.model.FunctionType
functionTypeDomain :: Typed.TypedTerm Model.FunctionType -> Typed.TypedTerm Model.Type
functionTypeDomain x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.FunctionType"),
        Model.projectionFieldName = (Model.Name "domain")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.FunctionType
functionTypeFunctionType :: Typed.TypedName Model.FunctionType
functionTypeFunctionType = Typed.TypedName (Model.Name "hydra.core.model.FunctionType")

-- | DSL updater for the codomain field of hydra.core.model.FunctionType
functionTypeWithCodomain :: Typed.TypedTerm Model.FunctionType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.FunctionType
functionTypeWithCodomain original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FunctionType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.FunctionType"),
              Model.projectionFieldName = (Model.Name "domain")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "codomain"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the domain field of hydra.core.model.FunctionType
functionTypeWithDomain :: Typed.TypedTerm Model.FunctionType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.FunctionType
functionTypeWithDomain original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.FunctionType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "codomain"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.FunctionType"),
              Model.projectionFieldName = (Model.Name "codomain")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.Injection
injection :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Injection
injection typeName field =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Injection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm typeName)},
        Model.Field {
          Model.fieldName = (Model.Name "field"),
          Model.fieldTerm = (Typed.unTypedTerm field)}]}))

-- | DSL accessor for the field field of hydra.core.model.Injection
injectionField :: Typed.TypedTerm Model.Injection -> Typed.TypedTerm Model.Field
injectionField x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Injection"),
        Model.projectionFieldName = (Model.Name "field")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Injection
injectionInjection :: Typed.TypedName Model.Injection
injectionInjection = Typed.TypedName (Model.Name "hydra.core.model.Injection")

-- | DSL accessor for the typeName field of hydra.core.model.Injection
injectionTypeName :: Typed.TypedTerm Model.Injection -> Typed.TypedTerm Model.Name
injectionTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Injection"),
        Model.projectionFieldName = (Model.Name "typeName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the field field of hydra.core.model.Injection
injectionWithField :: Typed.TypedTerm Model.Injection -> Typed.TypedTerm Model.Field -> Typed.TypedTerm Model.Injection
injectionWithField original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Injection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Injection"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "field"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the typeName field of hydra.core.model.Injection
injectionWithTypeName :: Typed.TypedTerm Model.Injection -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Injection
injectionWithTypeName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Injection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "field"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Injection"),
              Model.projectionFieldName = (Model.Name "field")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the bigint variant of hydra.core.model.IntegerType
integerTypeBigint :: Typed.TypedTerm Model.IntegerType
integerTypeBigint =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bigint"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int16 variant of hydra.core.model.IntegerType
integerTypeInt16 :: Typed.TypedTerm Model.IntegerType
integerTypeInt16 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int16"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int32 variant of hydra.core.model.IntegerType
integerTypeInt32 :: Typed.TypedTerm Model.IntegerType
integerTypeInt32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int64 variant of hydra.core.model.IntegerType
integerTypeInt64 :: Typed.TypedTerm Model.IntegerType
integerTypeInt64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int8 variant of hydra.core.model.IntegerType
integerTypeInt8 :: Typed.TypedTerm Model.IntegerType
integerTypeInt8 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int8"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.core.model.IntegerType
integerTypeIntegerType :: Typed.TypedName Model.IntegerType
integerTypeIntegerType = Typed.TypedName (Model.Name "hydra.core.model.IntegerType")

-- | DSL injection for the uint16 variant of hydra.core.model.IntegerType
integerTypeUint16 :: Typed.TypedTerm Model.IntegerType
integerTypeUint16 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint16"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint32 variant of hydra.core.model.IntegerType
integerTypeUint32 :: Typed.TypedTerm Model.IntegerType
integerTypeUint32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint64 variant of hydra.core.model.IntegerType
integerTypeUint64 :: Typed.TypedTerm Model.IntegerType
integerTypeUint64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint8 variant of hydra.core.model.IntegerType
integerTypeUint8 :: Typed.TypedTerm Model.IntegerType
integerTypeUint8 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint8"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bigint variant of hydra.core.model.IntegerValue
integerValueBigint :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.IntegerValue
integerValueBigint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bigint"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the int16 variant of hydra.core.model.IntegerValue
integerValueInt16 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Model.IntegerValue
integerValueInt16 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int16"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the int32 variant of hydra.core.model.IntegerValue
integerValueInt32 :: Typed.TypedTerm Int -> Typed.TypedTerm Model.IntegerValue
integerValueInt32 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int32"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the int64 variant of hydra.core.model.IntegerValue
integerValueInt64 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Model.IntegerValue
integerValueInt64 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int64"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the int8 variant of hydra.core.model.IntegerValue
integerValueInt8 :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm Model.IntegerValue
integerValueInt8 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int8"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.IntegerValue
integerValueIntegerValue :: Typed.TypedName Model.IntegerValue
integerValueIntegerValue = Typed.TypedName (Model.Name "hydra.core.model.IntegerValue")

-- | DSL injection for the uint16 variant of hydra.core.model.IntegerValue
integerValueUint16 :: Typed.TypedTerm Int -> Typed.TypedTerm Model.IntegerValue
integerValueUint16 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint16"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the uint32 variant of hydra.core.model.IntegerValue
integerValueUint32 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Model.IntegerValue
integerValueUint32 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint32"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the uint64 variant of hydra.core.model.IntegerValue
integerValueUint64 :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.IntegerValue
integerValueUint64 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint64"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the uint8 variant of hydra.core.model.IntegerValue
integerValueUint8 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Model.IntegerValue
integerValueUint8 x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.IntegerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint8"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.model.Lambda
lambda :: Typed.TypedTerm Model.Name -> Typed.TypedTerm (Maybe Model.Type) -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Lambda
lambda parameter domain body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Lambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)},
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Typed.unTypedTerm domain)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.core.model.Lambda
lambdaBody :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm Model.Term
lambdaBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the domain field of hydra.core.model.Lambda
lambdaDomain :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm (Maybe Model.Type)
lambdaDomain x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
        Model.projectionFieldName = (Model.Name "domain")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Lambda
lambdaLambda :: Typed.TypedName Model.Lambda
lambdaLambda = Typed.TypedName (Model.Name "hydra.core.model.Lambda")

-- | DSL accessor for the parameter field of hydra.core.model.Lambda
lambdaParameter :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm Model.Name
lambdaParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.core.model.Lambda
lambdaWithBody :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Lambda
lambdaWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Lambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "domain")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the domain field of hydra.core.model.Lambda
lambdaWithDomain :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm (Maybe Model.Type) -> Typed.TypedTerm Model.Lambda
lambdaWithDomain original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Lambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameter field of hydra.core.model.Lambda
lambdaWithParameter :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Lambda
lambdaWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Lambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "domain"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "domain")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Lambda"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.Let
let_ :: Typed.TypedTerm [Model.Binding] -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Let
let_ bindings body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Let"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Typed.unTypedTerm bindings)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the bindings field of hydra.core.model.Let
letBindings :: Typed.TypedTerm Model.Let -> Typed.TypedTerm [Model.Binding]
letBindings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Let"),
        Model.projectionFieldName = (Model.Name "bindings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.core.model.Let
letBody :: Typed.TypedTerm Model.Let -> Typed.TypedTerm Model.Term
letBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Let"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Let
letLet :: Typed.TypedName Model.Let
letLet = Typed.TypedName (Model.Name "hydra.core.model.Let")

-- | DSL updater for the bindings field of hydra.core.model.Let
letWithBindings :: Typed.TypedTerm Model.Let -> Typed.TypedTerm [Model.Binding] -> Typed.TypedTerm Model.Let
letWithBindings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Let"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Let"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.core.model.Let
letWithBody :: Typed.TypedTerm Model.Let -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Let
letWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Let"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "bindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Let"),
              Model.projectionFieldName = (Model.Name "bindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the binary variant of hydra.core.model.Literal
literalBinary :: Typed.TypedTerm B.ByteString -> Typed.TypedTerm Model.Literal
literalBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the boolean variant of hydra.core.model.Literal
literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Model.Literal
literalBoolean x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the decimal variant of hydra.core.model.Literal
literalDecimal :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Model.Literal
literalDecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the float variant of hydra.core.model.Literal
literalFloat :: Typed.TypedTerm Model.FloatValue -> Typed.TypedTerm Model.Literal
literalFloat x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the integer variant of hydra.core.model.Literal
literalInteger :: Typed.TypedTerm Model.IntegerValue -> Typed.TypedTerm Model.Literal
literalInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.Literal
literalLiteral :: Typed.TypedName Model.Literal
literalLiteral = Typed.TypedName (Model.Name "hydra.core.model.Literal")

-- | DSL injection for the string variant of hydra.core.model.Literal
literalString :: Typed.TypedTerm String -> Typed.TypedTerm Model.Literal
literalString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.core.model.LiteralType
literalTypeBinary :: Typed.TypedTerm Model.LiteralType
literalTypeBinary =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the boolean variant of hydra.core.model.LiteralType
literalTypeBoolean :: Typed.TypedTerm Model.LiteralType
literalTypeBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the decimal variant of hydra.core.model.LiteralType
literalTypeDecimal :: Typed.TypedTerm Model.LiteralType
literalTypeDecimal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.core.model.LiteralType
literalTypeFloat :: Typed.TypedTerm Model.FloatType -> Typed.TypedTerm Model.LiteralType
literalTypeFloat x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the integer variant of hydra.core.model.LiteralType
literalTypeInteger :: Typed.TypedTerm Model.IntegerType -> Typed.TypedTerm Model.LiteralType
literalTypeInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.LiteralType
literalTypeLiteralType :: Typed.TypedName Model.LiteralType
literalTypeLiteralType = Typed.TypedName (Model.Name "hydra.core.model.LiteralType")

-- | DSL injection for the string variant of hydra.core.model.LiteralType
literalTypeString :: Typed.TypedTerm Model.LiteralType
literalTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.LiteralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.core.model.MapType
mapType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.MapType
mapType keys values =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Typed.unTypedTerm keys)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm values)}]}))

-- | DSL accessor for the keys field of hydra.core.model.MapType
mapTypeKeys :: Typed.TypedTerm Model.MapType -> Typed.TypedTerm Model.Type
mapTypeKeys x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.MapType"),
        Model.projectionFieldName = (Model.Name "keys")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.MapType
mapTypeMapType :: Typed.TypedName Model.MapType
mapTypeMapType = Typed.TypedName (Model.Name "hydra.core.model.MapType")

-- | DSL accessor for the values field of hydra.core.model.MapType
mapTypeValues :: Typed.TypedTerm Model.MapType -> Typed.TypedTerm Model.Type
mapTypeValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.MapType"),
        Model.projectionFieldName = (Model.Name "values")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the keys field of hydra.core.model.MapType
mapTypeWithKeys :: Typed.TypedTerm Model.MapType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.MapType
mapTypeWithKeys original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.MapType"),
              Model.projectionFieldName = (Model.Name "values")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the values field of hydra.core.model.MapType
mapTypeWithValues :: Typed.TypedTerm Model.MapType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.MapType
mapTypeWithValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.MapType"),
              Model.projectionFieldName = (Model.Name "keys")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.core.model.Name wrapper
name :: Typed.TypedTerm String -> Typed.TypedTerm Model.Name
name x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.model.Name"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Name
nameName :: Typed.TypedName Model.Name
nameName = Typed.TypedName (Model.Name "hydra.core.model.Name")

-- | DSL constructor for hydra.core.model.PairType
pairType :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.PairType
pairType first second =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.PairType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "first"),
          Model.fieldTerm = (Typed.unTypedTerm first)},
        Model.Field {
          Model.fieldName = (Model.Name "second"),
          Model.fieldTerm = (Typed.unTypedTerm second)}]}))

-- | DSL accessor for the first field of hydra.core.model.PairType
pairTypeFirst :: Typed.TypedTerm Model.PairType -> Typed.TypedTerm Model.Type
pairTypeFirst x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.PairType"),
        Model.projectionFieldName = (Model.Name "first")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.PairType
pairTypePairType :: Typed.TypedName Model.PairType
pairTypePairType = Typed.TypedName (Model.Name "hydra.core.model.PairType")

-- | DSL accessor for the second field of hydra.core.model.PairType
pairTypeSecond :: Typed.TypedTerm Model.PairType -> Typed.TypedTerm Model.Type
pairTypeSecond x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.PairType"),
        Model.projectionFieldName = (Model.Name "second")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the first field of hydra.core.model.PairType
pairTypeWithFirst :: Typed.TypedTerm Model.PairType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.PairType
pairTypeWithFirst original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.PairType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "first"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "second"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.PairType"),
              Model.projectionFieldName = (Model.Name "second")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the second field of hydra.core.model.PairType
pairTypeWithSecond :: Typed.TypedTerm Model.PairType -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.PairType
pairTypeWithSecond original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.PairType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "first"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.PairType"),
              Model.projectionFieldName = (Model.Name "first")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "second"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.core.model.Projection
projection :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Projection
projection typeName fieldName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm typeName)},
        Model.Field {
          Model.fieldName = (Model.Name "fieldName"),
          Model.fieldTerm = (Typed.unTypedTerm fieldName)}]}))

-- | DSL accessor for the fieldName field of hydra.core.model.Projection
projectionFieldName :: Typed.TypedTerm Model.Projection -> Typed.TypedTerm Model.Name
projectionFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Projection"),
        Model.projectionFieldName = (Model.Name "fieldName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Projection
projectionProjection :: Typed.TypedName Model.Projection
projectionProjection = Typed.TypedName (Model.Name "hydra.core.model.Projection")

-- | DSL accessor for the typeName field of hydra.core.model.Projection
projectionTypeName :: Typed.TypedTerm Model.Projection -> Typed.TypedTerm Model.Name
projectionTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Projection"),
        Model.projectionFieldName = (Model.Name "typeName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the fieldName field of hydra.core.model.Projection
projectionWithFieldName :: Typed.TypedTerm Model.Projection -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Projection
projectionWithFieldName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Projection"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fieldName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the typeName field of hydra.core.model.Projection
projectionWithTypeName :: Typed.TypedTerm Model.Projection -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Projection
projectionWithTypeName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Projection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fieldName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Projection"),
              Model.projectionFieldName = (Model.Name "fieldName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.core.model.Record
record :: Typed.TypedTerm Model.Name -> Typed.TypedTerm [Model.Field] -> Typed.TypedTerm Model.Record
record typeName fields =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Record"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm typeName)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)}]}))

-- | DSL accessor for the fields field of hydra.core.model.Record
recordFields :: Typed.TypedTerm Model.Record -> Typed.TypedTerm [Model.Field]
recordFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Record"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.Record
recordRecord :: Typed.TypedName Model.Record
recordRecord = Typed.TypedName (Model.Name "hydra.core.model.Record")

-- | DSL accessor for the typeName field of hydra.core.model.Record
recordTypeName :: Typed.TypedTerm Model.Record -> Typed.TypedTerm Model.Name
recordTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.Record"),
        Model.projectionFieldName = (Model.Name "typeName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the fields field of hydra.core.model.Record
recordWithFields :: Typed.TypedTerm Model.Record -> Typed.TypedTerm [Model.Field] -> Typed.TypedTerm Model.Record
recordWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Record"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Record"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the typeName field of hydra.core.model.Record
recordWithTypeName :: Typed.TypedTerm Model.Record -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Record
recordWithTypeName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.Record"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.Record"),
              Model.projectionFieldName = (Model.Name "fields")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the annotated variant of hydra.core.model.Term
termAnnotated :: Typed.TypedTerm Model.AnnotatedTerm -> Typed.TypedTerm Model.Term
termAnnotated x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "annotated"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the application variant of hydra.core.model.Term
termApplication :: Typed.TypedTerm Model.Application -> Typed.TypedTerm Model.Term
termApplication x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "application"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the cases variant of hydra.core.model.Term
termCases :: Typed.TypedTerm Model.CaseStatement -> Typed.TypedTerm Model.Term
termCases x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "cases"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the either variant of hydra.core.model.Term
termEither :: Typed.TypedTerm (Either Model.Term Model.Term) -> Typed.TypedTerm Model.Term
termEither x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "either"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the inject variant of hydra.core.model.Term
termInject :: Typed.TypedTerm Model.Injection -> Typed.TypedTerm Model.Term
termInject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inject"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambda variant of hydra.core.model.Term
termLambda :: Typed.TypedTerm Model.Lambda -> Typed.TypedTerm Model.Term
termLambda x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lambda"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the let variant of hydra.core.model.Term
termLet :: Typed.TypedTerm Model.Let -> Typed.TypedTerm Model.Term
termLet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "let"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the list variant of hydra.core.model.Term
termList :: Typed.TypedTerm [Model.Term] -> Typed.TypedTerm Model.Term
termList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.core.model.Term
termLiteral :: Typed.TypedTerm Model.Literal -> Typed.TypedTerm Model.Term
termLiteral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.core.model.Term
termMap :: Typed.TypedTerm (M.Map Model.Term Model.Term) -> Typed.TypedTerm Model.Term
termMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the optional variant of hydra.core.model.Term
termOptional :: Typed.TypedTerm (Maybe Model.Term) -> Typed.TypedTerm Model.Term
termOptional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "optional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pair variant of hydra.core.model.Term
termPair :: Typed.TypedTerm (Model.Term, Model.Term) -> Typed.TypedTerm Model.Term
termPair x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pair"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the project variant of hydra.core.model.Term
termProject :: Typed.TypedTerm Model.Projection -> Typed.TypedTerm Model.Term
termProject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "project"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the record variant of hydra.core.model.Term
termRecord :: Typed.TypedTerm Model.Record -> Typed.TypedTerm Model.Term
termRecord x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "record"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the set variant of hydra.core.model.Term
termSet :: Typed.TypedTerm (S.Set Model.Term) -> Typed.TypedTerm Model.Term
termSet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "set"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.Term
termTerm :: Typed.TypedName Model.Term
termTerm = Typed.TypedName (Model.Name "hydra.core.model.Term")

-- | DSL injection for the typeApplication variant of hydra.core.model.Term
termTypeApplication :: Typed.TypedTerm Model.TypeApplicationTerm -> Typed.TypedTerm Model.Term
termTypeApplication x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeApplication"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLambda variant of hydra.core.model.Term
termTypeLambda :: Typed.TypedTerm Model.TypeLambda -> Typed.TypedTerm Model.Term
termTypeLambda x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeLambda"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unit variant of hydra.core.model.Term
termUnit :: Typed.TypedTerm Model.Term
termUnit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unwrap variant of hydra.core.model.Term
termUnwrap :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term
termUnwrap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unwrap"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the variable variant of hydra.core.model.Term
termVariable :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term
termVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the wrap variant of hydra.core.model.Term
termWrap :: Typed.TypedTerm Model.WrappedTerm -> Typed.TypedTerm Model.Term
termWrap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Term"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "wrap"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the annotated variant of hydra.core.model.Type
typeAnnotated :: Typed.TypedTerm Model.AnnotatedType -> Typed.TypedTerm Model.Type
typeAnnotated x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "annotated"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the application variant of hydra.core.model.Type
typeApplication :: Typed.TypedTerm Model.ApplicationType -> Typed.TypedTerm Model.Type
typeApplication x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "application"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.model.TypeApplicationTerm
typeApplicationTerm :: Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.TypeApplicationTerm
typeApplicationTerm body type_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the body field of hydra.core.model.TypeApplicationTerm
typeApplicationTermBody :: Typed.TypedTerm Model.TypeApplicationTerm -> Typed.TypedTerm Model.Term
typeApplicationTermBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.core.model.TypeApplicationTerm
typeApplicationTermType :: Typed.TypedTerm Model.TypeApplicationTerm -> Typed.TypedTerm Model.Type
typeApplicationTermType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.TypeApplicationTerm
typeApplicationTermTypeApplicationTerm :: Typed.TypedName Model.TypeApplicationTerm
typeApplicationTermTypeApplicationTerm = Typed.TypedName (Model.Name "hydra.core.model.TypeApplicationTerm")

-- | DSL updater for the body field of hydra.core.model.TypeApplicationTerm
typeApplicationTermWithBody :: Typed.TypedTerm Model.TypeApplicationTerm -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.TypeApplicationTerm
typeApplicationTermWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.core.model.TypeApplicationTerm
typeApplicationTermWithType :: Typed.TypedTerm Model.TypeApplicationTerm -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.TypeApplicationTerm
typeApplicationTermWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeApplicationTerm"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the simple variant of hydra.core.model.TypeClassConstraint
typeClassConstraintSimple :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.TypeClassConstraint
typeClassConstraintSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.TypeClassConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.TypeClassConstraint
typeClassConstraintTypeClassConstraint :: Typed.TypedName Model.TypeClassConstraint
typeClassConstraintTypeClassConstraint = Typed.TypedName (Model.Name "hydra.core.model.TypeClassConstraint")

-- | DSL injection for the effect variant of hydra.core.model.Type
typeEffect :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type
typeEffect x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "effect"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the either variant of hydra.core.model.Type
typeEither :: Typed.TypedTerm Model.EitherType -> Typed.TypedTerm Model.Type
typeEither x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "either"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the forall variant of hydra.core.model.Type
typeForall :: Typed.TypedTerm Model.ForallType -> Typed.TypedTerm Model.Type
typeForall x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "forall"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the function variant of hydra.core.model.Type
typeFunction :: Typed.TypedTerm Model.FunctionType -> Typed.TypedTerm Model.Type
typeFunction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "function"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.model.TypeLambda
typeLambda :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.TypeLambda
typeLambda parameter body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeLambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.core.model.TypeLambda
typeLambdaBody :: Typed.TypedTerm Model.TypeLambda -> Typed.TypedTerm Model.Term
typeLambdaBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeLambda"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameter field of hydra.core.model.TypeLambda
typeLambdaParameter :: Typed.TypedTerm Model.TypeLambda -> Typed.TypedTerm Model.Name
typeLambdaParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeLambda"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.TypeLambda
typeLambdaTypeLambda :: Typed.TypedName Model.TypeLambda
typeLambdaTypeLambda = Typed.TypedName (Model.Name "hydra.core.model.TypeLambda")

-- | DSL updater for the body field of hydra.core.model.TypeLambda
typeLambdaWithBody :: Typed.TypedTerm Model.TypeLambda -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.TypeLambda
typeLambdaWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeLambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeLambda"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the parameter field of hydra.core.model.TypeLambda
typeLambdaWithParameter :: Typed.TypedTerm Model.TypeLambda -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.TypeLambda
typeLambdaWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeLambda"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeLambda"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the list variant of hydra.core.model.Type
typeList :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type
typeList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.core.model.Type
typeLiteral :: Typed.TypedTerm Model.LiteralType -> Typed.TypedTerm Model.Type
typeLiteral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.core.model.Type
typeMap :: Typed.TypedTerm Model.MapType -> Typed.TypedTerm Model.Type
typeMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the optional variant of hydra.core.model.Type
typeOptional :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type
typeOptional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "optional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pair variant of hydra.core.model.Type
typePair :: Typed.TypedTerm Model.PairType -> Typed.TypedTerm Model.Type
typePair x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pair"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the record variant of hydra.core.model.Type
typeRecord :: Typed.TypedTerm [Model.FieldType] -> Typed.TypedTerm Model.Type
typeRecord x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "record"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.model.TypeScheme
typeScheme :: Typed.TypedTerm [Model.Name] -> Typed.TypedTerm Model.Type -> Typed.TypedTerm (M.Map Model.Name Model.TypeVariableConstraints) -> Typed.TypedTerm Model.TypeScheme
typeScheme variables body constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeScheme"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "variables"),
          Model.fieldTerm = (Typed.unTypedTerm variables)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the body field of hydra.core.model.TypeScheme
typeSchemeBody :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm Model.Type
typeSchemeBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the constraints field of hydra.core.model.TypeScheme
typeSchemeConstraints :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm (M.Map Model.Name Model.TypeVariableConstraints)
typeSchemeConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.TypeScheme
typeSchemeTypeScheme :: Typed.TypedName Model.TypeScheme
typeSchemeTypeScheme = Typed.TypedName (Model.Name "hydra.core.model.TypeScheme")

-- | DSL accessor for the variables field of hydra.core.model.TypeScheme
typeSchemeVariables :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm [Model.Name]
typeSchemeVariables x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
        Model.projectionFieldName = (Model.Name "variables")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.core.model.TypeScheme
typeSchemeWithBody :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.TypeScheme
typeSchemeWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeScheme"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "variables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "variables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the constraints field of hydra.core.model.TypeScheme
typeSchemeWithConstraints :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm (M.Map Model.Name Model.TypeVariableConstraints) -> Typed.TypedTerm Model.TypeScheme
typeSchemeWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeScheme"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "variables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "variables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the variables field of hydra.core.model.TypeScheme
typeSchemeWithVariables :: Typed.TypedTerm Model.TypeScheme -> Typed.TypedTerm [Model.Name] -> Typed.TypedTerm Model.TypeScheme
typeSchemeWithVariables original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeScheme"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "variables"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.TypeScheme"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the set variant of hydra.core.model.Type
typeSet :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type
typeSet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "set"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.core.model.Type
typeType :: Typed.TypedName Model.Type
typeType = Typed.TypedName (Model.Name "hydra.core.model.Type")

-- | DSL injection for the union variant of hydra.core.model.Type
typeUnion :: Typed.TypedTerm [Model.FieldType] -> Typed.TypedTerm Model.Type
typeUnion x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "union"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unit variant of hydra.core.model.Type
typeUnit :: Typed.TypedTerm Model.Type
typeUnit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the variable variant of hydra.core.model.Type
typeVariable :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Type
typeVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.core.model.TypeVariableConstraints
typeVariableConstraints :: Typed.TypedTerm (S.Set Model.TypeClassConstraint) -> Typed.TypedTerm Model.TypeVariableConstraints
typeVariableConstraints classes =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeVariableConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "classes"),
          Model.fieldTerm = (Typed.unTypedTerm classes)}]}))

-- | DSL accessor for the classes field of hydra.core.model.TypeVariableConstraints
typeVariableConstraintsClasses :: Typed.TypedTerm Model.TypeVariableConstraints -> Typed.TypedTerm (S.Set Model.TypeClassConstraint)
typeVariableConstraintsClasses x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.TypeVariableConstraints"),
        Model.projectionFieldName = (Model.Name "classes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.core.model.TypeVariableConstraints
typeVariableConstraintsTypeVariableConstraints :: Typed.TypedName Model.TypeVariableConstraints
typeVariableConstraintsTypeVariableConstraints = Typed.TypedName (Model.Name "hydra.core.model.TypeVariableConstraints")

-- | DSL updater for the classes field of hydra.core.model.TypeVariableConstraints
typeVariableConstraintsWithClasses :: Typed.TypedTerm Model.TypeVariableConstraints -> Typed.TypedTerm (S.Set Model.TypeClassConstraint) -> Typed.TypedTerm Model.TypeVariableConstraints
typeVariableConstraintsWithClasses original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.TypeVariableConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "classes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the void variant of hydra.core.model.Type
typeVoid :: Typed.TypedTerm Model.Type
typeVoid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "void"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the wrap variant of hydra.core.model.Type
typeWrap :: Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type
typeWrap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.core.model.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "wrap"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the body of hydra.core.model.Name
unName :: Typed.TypedTerm Model.Name -> Typed.TypedTerm String
unName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.core.model.Name")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.core.model.WrappedTerm
wrappedTerm :: Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.WrappedTerm
wrappedTerm typeName body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm typeName)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.core.model.WrappedTerm
wrappedTermBody :: Typed.TypedTerm Model.WrappedTerm -> Typed.TypedTerm Model.Term
wrappedTermBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeName field of hydra.core.model.WrappedTerm
wrappedTermTypeName :: Typed.TypedTerm Model.WrappedTerm -> Typed.TypedTerm Model.Name
wrappedTermTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
        Model.projectionFieldName = (Model.Name "typeName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.core.model.WrappedTerm
wrappedTermWithBody :: Typed.TypedTerm Model.WrappedTerm -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.WrappedTerm
wrappedTermWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
              Model.projectionFieldName = (Model.Name "typeName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the typeName field of hydra.core.model.WrappedTerm
wrappedTermWithTypeName :: Typed.TypedTerm Model.WrappedTerm -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Model.WrappedTerm
wrappedTermWithTypeName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "typeName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.core.model.WrappedTerm"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.core.model.WrappedTerm
wrappedTermWrappedTerm :: Typed.TypedName Model.WrappedTerm
wrappedTermWrappedTerm = Typed.TypedName (Model.Name "hydra.core.model.WrappedTerm")