hydra-0.14.0: src/gen-main/haskell/Hydra/Sources/Decode/Testing.hs
-- Note: this is an automatically generated file. Do not edit.
-- | Source module for hydra.decode.testing
module Hydra.Sources.Decode.Testing where
import qualified Hydra.Core as Core
import qualified Hydra.Module as Module
import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.ByteString as B
import qualified Data.Int as I
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S
module_ :: Module.Module
module_ =
Module.Module {
Module.moduleNamespace = (Module.Namespace "hydra.decode.testing"),
Module.moduleDefinitions = [
Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.alphaConversionTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_term"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "oldVariable"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_oldVariable"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newVariable"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_newVariable"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "result"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_result"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "term"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))},
Core.Field {
Core.fieldName = (Core.Name "oldVariable"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_oldVariable"))},
Core.Field {
Core.fieldName = (Core.Name "newVariable"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_newVariable"))},
Core.Field {
Core.fieldName = (Core.Name "result"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_result"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.AlphaConversionTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))}),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.evaluationStyle"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eager"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "eager"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lazy"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "lazy"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.EvaluationStyle"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.caseConversionTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fromConvention"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_fromConvention"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "toConvention"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_toConvention"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fromString"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_fromString"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "toString"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_toString"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "fromConvention"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_fromConvention"))},
Core.Field {
Core.fieldName = (Core.Name "toConvention"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_toConvention"))},
Core.Field {
Core.fieldName = (Core.Name "fromString"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_fromString"))},
Core.Field {
Core.fieldName = (Core.Name "toString"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_toString"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.CaseConversionTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.delegatedEvaluationTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.DelegatedEvaluationTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.etaExpansionTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.EtaExpansionTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.deannotateTermTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.DeannotateTermTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.deannotateTypeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.DeannotateTypeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.flattenLetTermsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.FlattenLetTermsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.foldOperation"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sumInt32Literals"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "sumInt32Literals"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "collectListLengths"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "collectListLengths"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "collectLabels"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "collectLabels"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.FoldOperation"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.foldOverTermTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "traversalOrder"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.coders.traversalOrder"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_traversalOrder"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "operation"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.foldOperation"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_operation"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "traversalOrder"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_traversalOrder"))},
Core.Field {
Core.fieldName = (Core.Name "operation"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_operation"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.FoldOverTermTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.freeVariablesTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeSet")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.FreeVariablesTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.hoistPredicate"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "caseStatements"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "caseStatements"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applications"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "applications"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lists"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "lists"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nothing"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "nothing"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.HoistPredicate"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.hoistLetBindingsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.let"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.let"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.HoistLetBindingsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.hoistPolymorphicLetBindingsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.let"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.let"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.hoistSubtermsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "predicate"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.hoistPredicate"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_predicate"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "predicate"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_predicate"))},
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.HoistSubtermsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.hoistCaseStatementsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.HoistCaseStatementsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.termRewriter"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "replaceFooWithBar"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "replaceFooWithBar"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "replaceInt32WithInt64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "replaceInt32WithInt64"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TermRewriter"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.rewriteTermTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rewriter"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.termRewriter"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_rewriter"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "rewriter"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_rewriter"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.RewriteTermTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.typeRewriter"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "replaceStringWithInt32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TypeRewriter"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "replaceStringWithInt32"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TypeRewriter"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.rewriteTypeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rewriter"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.typeRewriter"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_rewriter"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "rewriter"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_rewriter"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.RewriteTypeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.evaluationTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "evaluationStyle"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.evaluationStyle"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_evaluationStyle"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "evaluationStyle"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_evaluationStyle"))},
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.EvaluationTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.inferenceFailureTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.InferenceFailureTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))}]}))))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.InferenceFailureTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.inferenceTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeScheme"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.InferenceTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.InferenceTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.jsonDecodeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_type"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "json"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_json"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "type"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},
Core.Field {
Core.fieldName = (Core.Name "json"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_json"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.JsonDecodeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.jsonEncodeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_term"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "term"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.JsonEncodeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.jsonParserTestCase"),
Module.termDefinitionTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.parserTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {
Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.testing.ParserTestCase")),
Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.json.model.Value"))}))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.jsonRoundtripTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_type"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_term"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "type"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},
Core.Field {
Core.fieldName = (Core.Name "term"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.JsonRoundtripTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.liftLambdaAboveLetTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.jsonWriterTestCase"),
Module.termDefinitionTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.writerTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {
Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.testing.WriterTestCase")),
Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.json.model.Value"))}))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.parserTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "a"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseResult")),
Core.applicationArgument = (Core.TermVariable (Core.Name "a"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.ParserTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [
Core.Name "a"],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {
Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.testing.ParserTestCase")),
Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.tag"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "wrap"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "wrappedTerm"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "b"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),
Core.projectionField = (Core.Name "body")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.Tag"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.testCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "union"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "inj"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "field"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Injection"),
Core.projectionField = (Core.Name "field")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fname"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "name")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "fterm"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
Core.projectionTypeName = (Core.Name "hydra.core.Field"),
Core.projectionField = (Core.Name "term")})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),
Core.bindingType = Nothing},
Core.Binding {
Core.bindingName = (Core.Name "variantMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))),
Core.applicationArgument = (Core.TermList [
Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "alphaConversion"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "alphaConversion"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.alphaConversionTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "caseConversion"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "caseConversion"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.caseConversionTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "deannotateTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "deannotateTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.deannotateTermTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "deannotateType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "deannotateType"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.deannotateTypeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "delegatedEvaluation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "delegatedEvaluation"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.delegatedEvaluationTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "etaExpansion"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "etaExpansion"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.etaExpansionTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "flattenLetTerms"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "flattenLetTerms"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.flattenLetTermsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "freeVariables"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "freeVariables"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.freeVariablesTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "evaluation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "evaluation"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.evaluationTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inference"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "inference"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.inferenceTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inferenceFailure"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "inferenceFailure"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.inferenceFailureTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "jsonDecode"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "jsonDecode"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.jsonDecodeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "jsonEncode"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "jsonEncode"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.jsonEncodeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "jsonParser"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "jsonParser"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.jsonParserTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "jsonRoundtrip"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "jsonRoundtrip"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.jsonRoundtripTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "jsonWriter"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "jsonWriter"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.jsonWriterTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "liftLambdaAboveLet"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "liftLambdaAboveLet"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.liftLambdaAboveLetTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "serialization"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "serialization"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.serializationTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "simplifyTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "simplifyTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.simplifyTermTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "topologicalSort"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "topologicalSort"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.topologicalSortTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "topologicalSortBindings"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "topologicalSortBindings"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.topologicalSortBindingsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "topologicalSortSCC"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "topologicalSortSCC"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.topologicalSortSCCTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeChecking"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "typeChecking"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.typeCheckingTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeCheckingFailure"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "typeCheckingFailure"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.typeCheckingFailureTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeReduction"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "typeReduction"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.typeReductionTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "normalizeTypeVariables"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "normalizeTypeVariables"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.normalizeTypeVariablesTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "foldOverTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "foldOverTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.foldOverTermTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rewriteTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "rewriteTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.rewriteTermTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rewriteType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "rewriteType"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.rewriteTypeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hoistSubterms"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "hoistSubterms"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.hoistSubtermsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hoistCaseStatements"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "hoistCaseStatements"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.hoistCaseStatementsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hoistLetBindings"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "hoistLetBindings"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.hoistLetBindingsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hoistPolymorphicLetBindings"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "hoistPolymorphicLetBindings"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.hoistPolymorphicLetBindingsTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "substInType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "substInType"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.substInTypeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variableOccursInType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "variableOccursInType"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.variableOccursInTypeTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unifyTypes"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "unifyTypes"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.unifyTypesTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "joinTypes"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "joinTypes"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.joinTypesTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unshadowVariables"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "unshadowVariables"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.unshadowVariablesTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))),
(Core.TermPair (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "validateCoreTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "t"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermUnion (Core.Injection {
Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),
Core.injectionField = Core.Field {
Core.fieldName = (Core.Name "validateCoreTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.testing.validateCoreTermTestCase")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))),
Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
Core.applicationArgument = (Core.TermList [
Core.TermLiteral (Core.LiteralString "no such field "),
(Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
(Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "f"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "f")),
Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))),
Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.testCaseWithMetadata"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_name"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "case"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.testCase"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_case"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_description"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "tags"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.tag"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_tags"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "name"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},
Core.Field {
Core.fieldName = (Core.Name "case"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_case"))},
Core.Field {
Core.fieldName = (Core.Name "description"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))},
Core.Field {
Core.fieldName = (Core.Name "tags"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_tags"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TestCaseWithMetadata"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.testGroup"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_name"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_description"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "subgroups"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.testGroup"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_subgroups"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cases"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.testing.testCaseWithMetadata"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_cases"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "name"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},
Core.Field {
Core.fieldName = (Core.Name "description"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))},
Core.Field {
Core.fieldName = (Core.Name "subgroups"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_subgroups"))},
Core.Field {
Core.fieldName = (Core.Name "cases"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_cases"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TestGroup"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.typeCheckingTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "outputTerm"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_outputTerm"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "outputType"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_outputType"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "outputTerm"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_outputTerm"))},
Core.Field {
Core.fieldName = (Core.Name "outputType"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_outputType"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TypeCheckingTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.typeCheckingFailureTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingFailureTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))}]}))))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TypeCheckingFailureTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.topologicalSortBindingsTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_bindings"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "bindings"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.topologicalSortTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "adjacencyList"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_adjacencyList"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))}))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "adjacencyList"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_adjacencyList"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TopologicalSortTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.topologicalSortSCCTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "adjacencyList"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_adjacencyList"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "integer"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "int32"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "i"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "adjacencyList"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_adjacencyList"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TopologicalSortSCCTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.serializationTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.SerializationTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.SerializationTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.simplifyTermTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.SimplifyTermTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.normalizeTypeVariablesTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.typeReductionTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.TypeReductionTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.writerTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "a"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.WriterTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [
Core.Name "a"],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {
Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.testing.WriterTestCase")),
Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.substInTypeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "substitution"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_substitution"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "substitution"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_substitution"))},
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.SubstInTypeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.variableOccursInTypeTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variable"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_variable"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_type"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "boolean"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "b"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "variable"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_variable"))},
Core.Field {
Core.fieldName = (Core.Name "type"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.VariableOccursInTypeTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.unshadowVariablesTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.UnshadowVariablesTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.unifyTypesTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "schemaTypes"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_schemaTypes"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_left"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_right"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "string"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "s"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeSubst"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "schemaTypes"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_schemaTypes"))},
Core.Field {
Core.fieldName = (Core.Name "left"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},
Core.Field {
Core.fieldName = (Core.Name "right"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.UnifyTypesTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.joinTypesTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_left"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_right"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeConstraint"))}))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_expected"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "left"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},
Core.Field {
Core.fieldName = (Core.Name "right"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))},
Core.Field {
Core.fieldName = (Core.Name "expected"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.JoinTypesTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))})),
(Module.DefinitionTerm (Module.TermDefinition {
Module.termDefinitionName = (Core.Name "hydra.decode.testing.validateCoreTermTestCase"),
Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "record"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "record"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermLet (Core.Let {
Core.letBindings = [
Core.Binding {
Core.bindingName = (Core.Name "fieldMap"),
Core.bindingTerm = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")),
Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),
Core.bindingType = Nothing}],
Core.letBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typed"))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "cx"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "raw"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "err"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "stripped"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "literal"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "v"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),
Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {
Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),
Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),
Core.caseStatementCases = [
Core.Field {
Core.fieldName = (Core.Name "boolean"),
Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "b"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_typed"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "input"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_input"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")),
Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "output"))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")),
Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidTermError"))}))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),
Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
Core.lambdaParameter = (Core.Name "field_output"),
Core.lambdaDomain = Nothing,
Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {
Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"),
Core.recordFields = [
Core.Field {
Core.fieldName = (Core.Name "typed"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_typed"))},
Core.Field {
Core.fieldName = (Core.Name "input"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_input"))},
Core.Field {
Core.fieldName = (Core.Name "output"),
Core.fieldTerm = (Core.TermVariable (Core.Name "field_output"))}]}))))})))}))})))}))})))}))}))})))}]})))),
Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})),
Core.applicationArgument = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermApplication (Core.Application {
Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),
Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))),
Module.termDefinitionType = (Just (Core.TypeScheme {
Core.typeSchemeVariables = [],
Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),
Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),
Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {
Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),
Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.ValidateCoreTermTestCase"))}))}))})),
Core.typeSchemeConstraints = Nothing}))}))],
Module.moduleTermDependencies = [
Module.Namespace "hydra.extract.helpers",
(Module.Namespace "hydra.lexical"),
(Module.Namespace "hydra.rewriting"),
(Module.Namespace "hydra.decode.core"),
(Module.Namespace "hydra.decode.ast"),
(Module.Namespace "hydra.decode.coders"),
(Module.Namespace "hydra.decode.error.core"),
(Module.Namespace "hydra.decode.graph"),
(Module.Namespace "hydra.decode.json.model"),
(Module.Namespace "hydra.decode.module"),
(Module.Namespace "hydra.decode.parsing"),
(Module.Namespace "hydra.decode.typing"),
(Module.Namespace "hydra.decode.util")],
Module.moduleTypeDependencies = [
Module.Namespace "hydra.testing",
(Module.Namespace "hydra.util")],
Module.moduleDescription = (Just "Term decoders for hydra.testing")}