Checking.hs

-- Note: this is an automatically generated file. Do not edit.
-- | Term encoders for hydra.error.checking

module Hydra.Encode.Error.Checking where
import qualified Hydra.Core as Core
import qualified Hydra.Encode.Core as EncodeCore
import qualified Hydra.Encode.Paths as Paths
import qualified Hydra.Encode.Typing as Typing
import qualified Hydra.Encode.Variants as Variants
import qualified Hydra.Error.Checking as Checking
import qualified Hydra.Haskell.Lib.Lists as Lists
import qualified Hydra.Haskell.Lib.Sets as Sets
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci
-- | Encoder for hydra.error.checking.CheckingError
checkingError :: Checking.CheckingError -> Core.Term
checkingError x =
    case x of
      Checking.CheckingErrorIncorrectUnification v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "incorrectUnification"),
          Core.fieldTerm = (incorrectUnificationError v0)}})
      Checking.CheckingErrorNotAForallType v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "notAForallType"),
          Core.fieldTerm = (notAForallTypeError v0)}})
      Checking.CheckingErrorNotAFunctionType v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "notAFunctionType"),
          Core.fieldTerm = (notAFunctionTypeError v0)}})
      Checking.CheckingErrorOther v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "other"),
          Core.fieldTerm = (otherCheckingError v0)}})
      Checking.CheckingErrorTypeArityMismatch v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeArityMismatch"),
          Core.fieldTerm = (typeArityMismatchError v0)}})
      Checking.CheckingErrorTypeMismatch v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "typeMismatch"),
          Core.fieldTerm = (typeMismatchError v0)}})
      Checking.CheckingErrorUnboundTypeVariables v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unboundTypeVariables"),
          Core.fieldTerm = (unboundTypeVariablesError v0)}})
      Checking.CheckingErrorUndefinedTermVariable v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "undefinedTermVariable"),
          Core.fieldTerm = (undefinedTermVariableCheckingError v0)}})
      Checking.CheckingErrorUnequalTypes v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unequalTypes"),
          Core.fieldTerm = (unequalTypesError v0)}})
      Checking.CheckingErrorUnsupportedTermVariant v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "unsupportedTermVariant"),
          Core.fieldTerm = (unsupportedTermVariantError v0)}})
      Checking.CheckingErrorUntypedLambda v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "untypedLambda"),
          Core.fieldTerm = (untypedLambdaError v0)}})
      Checking.CheckingErrorUntypedLetBinding v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "untypedLetBinding"),
          Core.fieldTerm = (untypedLetBindingError v0)}})
      Checking.CheckingErrorUntypedTermVariable v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "untypedTermVariable"),
          Core.fieldTerm = (untypedTermVariableCheckingError v0)}})
-- | Encoder for hydra.error.checking.IncorrectUnificationError
incorrectUnificationError :: Checking.IncorrectUnificationError -> Core.Term
incorrectUnificationError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "substitution"),
          Core.fieldTerm = (Typing.typeSubst (Checking.incorrectUnificationErrorSubstitution x))}]})
-- | Encoder for hydra.error.checking.NotAForallTypeError
notAForallTypeError :: Checking.NotAForallTypeError -> Core.Term
notAForallTypeError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.notAForallTypeErrorType x))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.notAForallTypeErrorTypeArguments x))}]})
-- | Encoder for hydra.error.checking.NotAFunctionTypeError
notAFunctionTypeError :: Checking.NotAFunctionTypeError -> Core.Term
notAFunctionTypeError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.notAFunctionTypeErrorType x))}]})
-- | Encoder for hydra.error.checking.OtherCheckingError
otherCheckingError :: Checking.OtherCheckingError -> Core.Term
otherCheckingError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Paths.subtermPath (Checking.otherCheckingErrorPath x))},
        Core.Field {
          Core.fieldName = (Core.Name "message"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Checking.otherCheckingErrorMessage x))}]})
-- | Encoder for hydra.error.checking.TypeArityMismatchError
typeArityMismatchError :: Checking.TypeArityMismatchError -> Core.Term
typeArityMismatchError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.typeArityMismatchErrorType x))},
        Core.Field {
          Core.fieldName = (Core.Name "expectedArity"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Checking.typeArityMismatchErrorExpectedArity x))},
        Core.Field {
          Core.fieldName = (Core.Name "actualArity"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Checking.typeArityMismatchErrorActualArity x))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.typeArityMismatchErrorTypeArguments x))}]})
-- | Encoder for hydra.error.checking.TypeMismatchError
typeMismatchError :: Checking.TypeMismatchError -> Core.Term
typeMismatchError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expectedType"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.typeMismatchErrorExpectedType x))},
        Core.Field {
          Core.fieldName = (Core.Name "actualType"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.typeMismatchErrorActualType x))}]})
-- | Encoder for hydra.error.checking.UnboundTypeVariablesError
unboundTypeVariablesError :: Checking.UnboundTypeVariablesError -> Core.Term
unboundTypeVariablesError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variables"),
          Core.fieldTerm = ((\s -> Core.TermSet (Sets.map EncodeCore.name s)) (Checking.unboundTypeVariablesErrorVariables x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (EncodeCore.type_ (Checking.unboundTypeVariablesErrorType x))}]})
-- | Encoder for hydra.error.checking.UndefinedTermVariableCheckingError
undefinedTermVariableCheckingError :: Checking.UndefinedTermVariableCheckingError -> Core.Term
undefinedTermVariableCheckingError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Paths.subtermPath (Checking.undefinedTermVariableCheckingErrorPath x))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Checking.undefinedTermVariableCheckingErrorName x))}]})
-- | Encoder for hydra.error.checking.UnequalTypesError
unequalTypesError :: Checking.UnequalTypesError -> Core.Term
unequalTypesError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "types"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.unequalTypesErrorTypes x))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Checking.unequalTypesErrorDescription x))}]})
-- | Encoder for hydra.error.checking.UnsupportedTermVariantError
unsupportedTermVariantError :: Checking.UnsupportedTermVariantError -> Core.Term
unsupportedTermVariantError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "termVariant"),
          Core.fieldTerm = (Variants.termVariant (Checking.unsupportedTermVariantErrorTermVariant x))}]})
-- | Encoder for hydra.error.checking.UntypedLambdaError
untypedLambdaError :: t0 -> Core.Term
untypedLambdaError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"),
      Core.recordFields = []})
-- | Encoder for hydra.error.checking.UntypedLetBindingError
untypedLetBindingError :: Checking.UntypedLetBindingError -> Core.Term
untypedLetBindingError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "binding"),
          Core.fieldTerm = (EncodeCore.binding (Checking.untypedLetBindingErrorBinding x))}]})
-- | Encoder for hydra.error.checking.UntypedTermVariableCheckingError
untypedTermVariableCheckingError :: Checking.UntypedTermVariableCheckingError -> Core.Term
untypedTermVariableCheckingError x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Paths.subtermPath (Checking.untypedTermVariableCheckingErrorPath x))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (EncodeCore.name (Checking.untypedTermVariableCheckingErrorName x))}]})