hydra-kernel-0.17.7: src/main/haskell/Hydra/Encode/Paths.hs

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

-- | Term encoders for hydra.paths

module Hydra.Encode.Paths where

import qualified Hydra.Core as Core
import qualified Hydra.Encode.Core as EncodeCore
import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
import qualified Hydra.Paths as Paths
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | Encoder for hydra.paths.LambdaVariableReference
lambdaVariableReference :: Paths.LambdaVariableReference -> Core.Term
lambdaVariableReference x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (EncodeCore.name (Paths.lambdaVariableReferenceVariable x))},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (termNodeId (Paths.lambdaVariableReferenceBoundByNode x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Paths.lambdaVariableReferenceType x))}]})

-- | Encoder for hydra.paths.LetVariableReference
letVariableReference :: Paths.LetVariableReference -> Core.Term
letVariableReference x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (EncodeCore.name (Paths.letVariableReferenceVariable x))},
        Core.Field {
          Core.fieldName = (Core.Name "bindingNode"),
          Core.fieldTerm = (termNodeId (Paths.letVariableReferenceBindingNode x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Paths.letVariableReferenceType x))}]})

-- | Encoder for hydra.paths.NominalTypeReference
nominalTypeReference :: Paths.NominalTypeReference -> Core.Term
nominalTypeReference x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Paths.nominalTypeReferenceName x))}]})

-- | Encoder for hydra.paths.PrimitiveReference
primitiveReference :: Paths.PrimitiveReference -> Core.Term
primitiveReference x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Paths.primitiveReferenceName x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Paths.primitiveReferenceType x))}]})

-- | Encoder for hydra.paths.SubtermLink
subtermLink :: Paths.SubtermLink -> Core.Term
subtermLink x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (subtermStep (Paths.subtermLinkStep x))},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (termNode (Paths.subtermLinkChild x))}]})

-- | Encoder for hydra.paths.SubtermPath
subtermPath :: Paths.SubtermPath -> Core.Term
subtermPath x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),
      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtermStep xs)) (Paths.unSubtermPath x))})

-- | Encoder for hydra.paths.SubtermStep
subtermStep :: Paths.SubtermStep -> Core.Term
subtermStep x =
    case x of
      Paths.SubtermStepAnnotatedAnnotation -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotatedAnnotation"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepAnnotatedBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotatedBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepApplicationArgument -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "applicationArgument"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepApplicationFunction -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "applicationFunction"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepCasesCase v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "casesCase"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtermStepCasesDefault -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "casesDefault"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepEitherLeft -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "eitherLeft"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepEitherRight -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "eitherRight"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepInjectField v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "injectField"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtermStepLambdaBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "lambdaBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepLetBinding v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "letBinding"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtermStepLetBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "letBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepListElement v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "listElement"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Paths.SubtermStepMapEntry v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "mapEntry"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Paths.SubtermStepOptionalGiven -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "optionalGiven"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepPairFirst -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pairFirst"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepPairSecond -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pairSecond"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepRecordField v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "recordField"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtermStepSetElement v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "setElement"),
          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})
      Paths.SubtermStepTypeApplicationBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeApplicationBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepTypeLambdaBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeLambdaBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtermStepWrapBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "wrapBody"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.paths.SubtypeLink
subtypeLink :: Paths.SubtypeLink -> Core.Term
subtypeLink x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (subtypeStep (Paths.subtypeLinkStep x))},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (typeNode (Paths.subtypeLinkChild x))}]})

-- | Encoder for hydra.paths.SubtypePath
subtypePath :: Paths.SubtypePath -> Core.Term
subtypePath x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),
      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtypeStep xs)) (Paths.unSubtypePath x))})

-- | Encoder for hydra.paths.SubtypeStep
subtypeStep :: Paths.SubtypeStep -> Core.Term
subtypeStep x =
    case x of
      Paths.SubtypeStepAnnotatedBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotatedBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepApplicationArgument -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "applicationArgument"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepApplicationFunction -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "applicationFunction"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepEffectValue -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "effectValue"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepEitherLeft -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "eitherLeft"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepEitherRight -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "eitherRight"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepForallBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "forallBody"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepFunctionCodomain -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "functionCodomain"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepFunctionDomain -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "functionDomain"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepListElement -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "listElement"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepMapKeys -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "mapKeys"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepMapValues -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "mapValues"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepOptionalElement -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "optionalElement"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepPairFirst -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pairFirst"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepPairSecond -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "pairSecond"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepRecordField v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "recordField"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtypeStepSetElement -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "setElement"),
          Core.fieldTerm = Core.TermUnit}})
      Paths.SubtypeStepUnionField v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unionField"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.SubtypeStepWrapBody -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "wrapBody"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.paths.TermAttributeLink
termAttributeLink :: Paths.TermAttributeLink -> Core.Term
termAttributeLink x =
    case x of
      Paths.TermAttributeLinkCasesTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "casesTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkInjectTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "injectTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkLambdaDomainGiven v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "lambdaDomainGiven"),
          Core.fieldTerm = (EncodeCore.type_ v0)}})
      Paths.TermAttributeLinkLambdaParameter v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "lambdaParameter"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkLetBindingTypeSchemeGiven v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "letBindingTypeSchemeGiven"),
          Core.fieldTerm = (Core.TermPair (Pairs.bimap EncodeCore.name EncodeCore.typeScheme v0))}})
      Paths.TermAttributeLinkLiteral v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "literal"),
          Core.fieldTerm = (EncodeCore.literal v0)}})
      Paths.TermAttributeLinkProjectFieldName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "projectFieldName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkProjectTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "projectTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkRecordTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "recordTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkTypeApplicationType v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeApplicationType"),
          Core.fieldTerm = (EncodeCore.type_ v0)}})
      Paths.TermAttributeLinkTypeLambdaParameter v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeLambdaParameter"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkUnwrapTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unwrapTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TermAttributeLinkWrapTypeName v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "wrapTypeName"),
          Core.fieldTerm = (EncodeCore.name v0)}})

-- | Encoder for hydra.paths.TermGraph
termGraph :: Paths.TermGraph -> Core.Term
termGraph x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name termNode m)) (Paths.termGraphRoots x))}]})

-- | Encoder for hydra.paths.TermLink
termLink :: Paths.TermLink -> Core.Term
termLink x =
    case x of
      Paths.TermLinkAttribute v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "attribute"),
          Core.fieldTerm = (termAttributeLink v0)}})
      Paths.TermLinkReference v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "reference"),
          Core.fieldTerm = (termReferenceLink v0)}})
      Paths.TermLinkSubterm v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "subterm"),
          Core.fieldTerm = (subtermLink v0)}})

-- | Encoder for hydra.paths.TermNode
termNode :: Paths.TermNode -> Core.Term
termNode x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (EncodeCore.term (Paths.termNodeTerm x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Paths.termNodeType x))},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map termLink xs)) (Paths.termNodeLinks x))}]})

-- | Encoder for hydra.paths.TermNodeId
termNodeId :: Paths.TermNodeId -> Core.Term
termNodeId x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (EncodeCore.name (Paths.termNodeIdRoot x))},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (subtermPath (Paths.termNodeIdPath x))}]})

-- | Encoder for hydra.paths.TermReference
termReference :: Paths.TermReference -> Core.Term
termReference x =
    case x of
      Paths.TermReferenceLambda v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "lambda"),
          Core.fieldTerm = (lambdaVariableReference v0)}})
      Paths.TermReferenceLet v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "let"),
          Core.fieldTerm = (letVariableReference v0)}})
      Paths.TermReferencePrimitive v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "primitive"),
          Core.fieldTerm = (primitiveReference v0)}})

-- | Encoder for hydra.paths.TermReferenceLink
termReferenceLink :: Paths.TermReferenceLink -> Core.Term
termReferenceLink x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (subtermStep (Paths.termReferenceLinkStep x))},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (termReference (Paths.termReferenceLinkTarget x))}]})

-- | Encoder for hydra.paths.TypeAttributeLink
typeAttributeLink :: Paths.TypeAttributeLink -> Core.Term
typeAttributeLink x =
    case x of
      Paths.TypeAttributeLinkAnnotatedAnnotation v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "annotatedAnnotation"),
          Core.fieldTerm = (EncodeCore.term v0)}})
      Paths.TypeAttributeLinkForallParameter v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "forallParameter"),
          Core.fieldTerm = (EncodeCore.name v0)}})
      Paths.TypeAttributeLinkLiteral v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "literal"),
          Core.fieldTerm = (EncodeCore.literalType v0)}})

-- | Encoder for hydra.paths.TypeGraph
typeGraph :: Paths.TypeGraph -> Core.Term
typeGraph x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name typeNode m)) (Paths.typeGraphRoots x))}]})

-- | Encoder for hydra.paths.TypeLink
typeLink :: Paths.TypeLink -> Core.Term
typeLink x =
    case x of
      Paths.TypeLinkAttribute v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "attribute"),
          Core.fieldTerm = (typeAttributeLink v0)}})
      Paths.TypeLinkReference v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "reference"),
          Core.fieldTerm = (typeReferenceLink v0)}})
      Paths.TypeLinkSubtype v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "subtype"),
          Core.fieldTerm = (subtypeLink v0)}})

-- | Encoder for hydra.paths.TypeNode
typeNode :: Paths.TypeNode -> Core.Term
typeNode x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Paths.typeNodeType x))},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeLink xs)) (Paths.typeNodeLinks x))}]})

-- | Encoder for hydra.paths.TypeNodeId
typeNodeId :: Paths.TypeNodeId -> Core.Term
typeNodeId x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (EncodeCore.name (Paths.typeNodeIdRoot x))},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (subtypePath (Paths.typeNodeIdPath x))}]})

-- | Encoder for hydra.paths.TypeReference
typeReference :: Paths.TypeReference -> Core.Term
typeReference x =
    case x of
      Paths.TypeReferenceNominal v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "nominal"),
          Core.fieldTerm = (nominalTypeReference v0)}})
      Paths.TypeReferenceVariable v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (typeVariableReference v0)}})

-- | Encoder for hydra.paths.TypeReferenceLink
typeReferenceLink :: Paths.TypeReferenceLink -> Core.Term
typeReferenceLink x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (subtypeStep (Paths.typeReferenceLinkStep x))},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (typeReference (Paths.typeReferenceLinkTarget x))}]})

-- | Encoder for hydra.paths.TypeVariableReference
typeVariableReference :: Paths.TypeVariableReference -> Core.Term
typeVariableReference x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (EncodeCore.name (Paths.typeVariableReferenceVariable x))},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (typeNodeId (Paths.typeVariableReferenceBoundByNode x))}]})