Typing.hs

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

-- | Term encoders for hydra.typing

module Hydra.Encode.Typing where

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

-- | Encoder for hydra.typing.FunctionStructure
functionStructure :: (env -> Core.Term) -> Typing.FunctionStructure env -> Core.Term
functionStructure env x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeParams"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.name xs)) (Typing.functionStructureTypeParams x))},
        Core.Field {
          Core.fieldName = (Core.Name "params"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.name xs)) (Typing.functionStructureParams x))},
        Core.Field {
          Core.fieldName = (Core.Name "bindings"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.binding xs)) (Typing.functionStructureBindings x))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (EncodeCore.term (Typing.functionStructureBody x))},
        Core.Field {
          Core.fieldName = (Core.Name "domains"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Typing.functionStructureDomains x))},
        Core.Field {
          Core.fieldName = (Core.Name "codomain"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.type_ opt)) (Typing.functionStructureCodomain x))},
        Core.Field {
          Core.fieldName = (Core.Name "environment"),
          Core.fieldTerm = (env (Typing.functionStructureEnvironment x))}]})

-- | Encoder for hydra.typing.InferenceContext
inferenceContext :: Typing.InferenceContext -> Core.Term
inferenceContext x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "freshTypeVariableCount"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Typing.inferenceContextFreshTypeVariableCount x))},
        Core.Field {
          Core.fieldName = (Core.Name "trace"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Paths.subtermStep xs)) (Typing.inferenceContextTrace x))}]})

-- | Encoder for hydra.typing.InferenceResult
inferenceResult :: Typing.InferenceResult -> Core.Term
inferenceResult x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (EncodeCore.term (Typing.inferenceResultTerm x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Typing.inferenceResultType x))},
        Core.Field {
          Core.fieldName = (Core.Name "subst"),
          Core.fieldTerm = (typeSubst (Typing.inferenceResultSubst x))},
        Core.Field {
          Core.fieldName = (Core.Name "classConstraints"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.typeVariableConstraints m)) (Typing.inferenceResultClassConstraints x))},
        Core.Field {
          Core.fieldName = (Core.Name "context"),
          Core.fieldTerm = (inferenceContext (Typing.inferenceResultContext x))}]})

-- | Encoder for hydra.typing.Parameter
parameter :: Typing.Parameter -> Core.Term
parameter x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Typing.parameterName x))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Typing.parameterDescription x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Typing.parameterType x))},
        Core.Field {
          Core.fieldName = (Core.Name "isLazy"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Typing.parameterIsLazy x))}]})

-- | Encoder for hydra.typing.Result
result :: Typing.Result -> Core.Term
result x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.Result"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Typing.resultDescription x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Typing.resultType x))}]})

-- | Encoder for hydra.typing.TermSignature
termSignature :: Typing.TermSignature -> Core.Term
termSignature x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeParameter xs)) (Typing.termSignatureTypeParameters x))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map parameter xs)) (Typing.termSignatureParameters x))},
        Core.Field {
          Core.fieldName = (Core.Name "result"),
          Core.fieldTerm = (result (Typing.termSignatureResult x))}]})

-- | Encoder for hydra.typing.TermSubst
termSubst :: Typing.TermSubst -> Core.Term
termSubst x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"),
      Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.term m)) (Typing.unTermSubst x))})

-- | Encoder for hydra.typing.TypeClass
typeClass :: Typing.TypeClass -> Core.Term
typeClass x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Typing.typeClassDescription x))}]})

-- | Encoder for hydra.typing.TypeConstraint
typeConstraint :: Typing.TypeConstraint -> Core.Term
typeConstraint x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (EncodeCore.type_ (Typing.typeConstraintLeft x))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (EncodeCore.type_ (Typing.typeConstraintRight x))},
        Core.Field {
          Core.fieldName = (Core.Name "comment"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Typing.typeConstraintComment x))}]})

-- | Encoder for hydra.typing.TypeParameter
typeParameter :: Typing.TypeParameter -> Core.Term
typeParameter x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Typing.typeParameterName x))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.typeClassConstraint xs)) (Typing.typeParameterConstraints x))}]})

-- | Encoder for hydra.typing.TypeSubst
typeSubst :: Typing.TypeSubst -> Core.Term
typeSubst x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"),
      Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.type_ m)) (Typing.unTypeSubst x))})