diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,204 @@ --- +## [0.16.1] - 2026-06-16 + +Major themes: the first release built by bootstrapping from previously published +packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and +published-package self-containment fixes for the artifacts that bootstrap rests on. + +### Highlights + +- **Bootstrap from published packages**: the build links the published 0.16.0 hosts + (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra, + resting on 0.16.0's forward-compatibility guarantees — the published-host consume + model with a `--local-host` shim, used for the first time in a release + ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds + against **local** Haskell and Python hosts (`hostOverrides`), because the published + 0.16.0 artifacts it would otherwise consume are the very ones being repaired below. +- **First full 9 × 9 bootstrapping sweep** — every implementation generating every + other; dozens of cross-host issues surfaced and fixed + ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing). +- **Published-package self-containment**: relocate each host's hand-written runtime + into `overlay//hydra-kernel/` so it ships inside the published `hydra-kernel` + artifact — Python `hydra.python.util` into the wheel + ([#461](https://github.com/CategoricalData/hydra/issues/461), + [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell + authoring DSL + `Libraries`/`Terms` into the sdist + ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a + uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts + ([#434](https://github.com/CategoricalData/hydra/issues/434)). +- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive + names are derived from generated `PrimitiveDefinition` def-modules rather than + hand-written name strings, in every host + ([#473](https://github.com/CategoricalData/hydra/issues/473)). +- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules + are synthesized at build time and excluded from `dist/`, with the synthesizer (not + inference) as the authority for their annotations + ([#448](https://github.com/CategoricalData/hydra/issues/448), + [#476](https://github.com/CategoricalData/hydra/issues/476)). +- **Release hardening**: Apache source-release compliance (signed source archive, + LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)), + per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)), + and packaging-boundary verification gated in CI and at publish time + ([#472](https://github.com/CategoricalData/hydra/issues/472)). + +### New features + +- Published-host consume model wired through `bin/sync.sh` for all three hosts + (`--published-host` default, `--local-host` shim), with the version basis keyed + off `hydra.json` and the `VERSION` file retired + ([#370](https://github.com/CategoricalData/hydra/issues/370), + [#347](https://github.com/CategoricalData/hydra/issues/347)). +- Java and Python coder DSL sources made the sole source of truth; the legacy + Haskell DSL copies were deleted and cross-package references resolve by name + ([#346](https://github.com/CategoricalData/hydra/issues/346)). +- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the + per-package trio and `stack build`s it; Python installs the wheels into an + isolated venv and imports the kernel modules; Java resolves the published jars + from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh` + ([#472](https://github.com/CategoricalData/hydra/issues/472)). +- Apache-compliant canonical source archive: signed + checksummed `git archive` + tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI + workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)). +- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with + dependency-closure and leaves-first ordering checks + ([#449](https://github.com/CategoricalData/hydra/issues/449)). +- `hydra-typescript` published as a target Java/Maven + PyPI artifact + ([#468](https://github.com/CategoricalData/hydra/issues/468)). +- Java coder emits a fluent builder for every generated record type + ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits + per-field `with_` copy-update methods and a fluent builder + ([#466](https://github.com/CategoricalData/hydra/issues/466)). + +### Improvements + +- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation` + carrier across all hosts; add a graph-free `funT` coder and six `lists` default + implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)). +- Derive package routing from declared modules; split derived generation into broad + `mainDslModules` and scoped `mainEncodingModules` + ([#474](https://github.com/CategoricalData/hydra/issues/474), + [#475](https://github.com/CategoricalData/hydra/issues/475)). +- Hash JSON content into the per-package input digest; add `digest-check + refresh-input` and a CI guard that force-regenerates and diffs + `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)). +- Per-package inference seeds downstream packages from each package's full universe + while inferring only write targets, fixing `hydra-scala` inference within the CI + heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold + ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)). +- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules` + manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)). +- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels + (`dist-info`); declare Apache-2.0 in the Scala build + ([#441](https://github.com/CategoricalData/hydra/issues/441)). +- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager + coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453), + [#477](https://github.com/CategoricalData/hydra/issues/477), + [#425](https://github.com/CategoricalData/hydra/issues/425)). +- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main` + ([#466](https://github.com/CategoricalData/hydra/issues/466)). + +### Bug fixes + +- **Python wheel self-containment**: the `hydra-kernel` wheel now ships + `hydra.python.util`; gated by a packaging-boundary smoke test in CI and + `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472), + [#461](https://github.com/CategoricalData/hydra/issues/461)). +- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs` + (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold + build of the published `hydra-kernel` + ([#473](https://github.com/CategoricalData/hydra/issues/473)). +- Decode synthesizer threads the fully-applied result type into wrap/record/union + decoder bodies, so derived decoders emit `DataRow` rather than raw `DataRow`, + fixing Java and Scala generic decode compilation + ([#476](https://github.com/CategoricalData/hydra/issues/476)). +- Scala coder emits explicit type arguments for polymorphic non-primitive + references under a type application (e.g. `requireField`), fixing `Any`-inference + of curried decoder lambda parameters in `decode/typed` + ([#434](https://github.com/CategoricalData/hydra/issues/434)). +- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path + so it no longer collides with the generated `hydra.lib.*` def-modules + ([#434](https://github.com/CategoricalData/hydra/issues/434)). +- Python coder uses the binding `TypeScheme` as the authoritative source for + parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488)); + fixes a duplicate `self` parameter in builders + ([#478](https://github.com/CategoricalData/hydra/issues/478)). +- Sort term definitions by name in source-file generation so non-Haskell hosts emit + deterministic alphabetical Haskell output (host-independent of `Maps.elems` + iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)). +- Java coder serializes the `static` method modifier (previously a non-exhaustive + case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc + `@link`/`@param` sanitization for strict doclint + ([#449](https://github.com/CategoricalData/hydra/issues/449)). +- Scala host writer appends a trailing newline when missing, fixing a Lisp-target + byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)). +- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel + contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order + and `--kernel-only` filter fixes after kernel renames + ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the + `hydra-haskell` baseline for Clojure→Haskell rebuilds + ([#487](https://github.com/CategoricalData/hydra/issues/487), + [#460](https://github.com/CategoricalData/hydra/issues/460)). +- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists + rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452), + also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read + module names via the correct struct accessor + ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale + surplus flag arguments from `generate-source-files` calls + ([#457](https://github.com/CategoricalData/hydra/issues/457), + [#458](https://github.com/CategoricalData/hydra/issues/458), + [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped + projection/unwrap parameters to avoid kernel shadowing + ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a + non-zero exit from the Scheme test runner on failures and fix Scheme float + scientific-notation formatting for `|x| >= 1e7` + ([#447](https://github.com/CategoricalData/hydra/issues/447)). +- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and + TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482), + [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host + target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5), + [#7](https://github.com/CategoricalData/hydra/issues/7), + [#17](https://github.com/CategoricalData/hydra/issues/17)). +- TypeScript test runtime reads the kernel JSON field names `body`/`signature` + (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON + ([#485](https://github.com/CategoricalData/hydra/issues/485)). +- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal + partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480)); + persist the run dir on bootstrap prep-phase failures + ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host + static deps so the bootstrap demo finds fresh dist + ([#445](https://github.com/CategoricalData/hydra/issues/445)). +- Pin the Python target test interpreter to Python ≥ 3.12 + ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme + target test-runner re-copy robustness + ([#456](https://github.com/CategoricalData/hydra/issues/456)). +- JavaDoc Pages publish rewritten to build a combined site from the CI-generated + `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a + bare checkout with no `dist/java/` present + ([#450](https://github.com/CategoricalData/hydra/issues/450)). + +### Documentation + +- Document the `overlay/` self-containment model, the published-host consume model + for all three hosts, the `hydra.json` version / host-version basis, and a + migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434), + [#370](https://github.com/CategoricalData/hydra/issues/370), + [#347](https://github.com/CategoricalData/hydra/issues/347)). +- Document the kernel self-containment / `hydra.lib.*` def-module model and the + derived-module no-inference invariant + ([#473](https://github.com/CategoricalData/hydra/issues/473), + [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and + Python record builders documented in the DSL guides + ([#465](https://github.com/CategoricalData/hydra/issues/465), + [#466](https://github.com/CategoricalData/hydra/issues/466)). +- Use absolute GitHub URLs in package READMEs so links resolve when published + standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a + README into each Python package dir for sdist metadata + ([#418](https://github.com/CategoricalData/hydra/issues/418)). + +--- + ## [0.16.0] - 2026-06-09 Major themes: primitive-metadata reification, self-hosting coder DSLs with all diff --git a/NOTICE b/NOTICE new file mode 100644 --- /dev/null +++ b/NOTICE @@ -0,0 +1,3 @@ +Hydra +Copyright 2021-2026 The Hydra authors +https://github.com/CategoricalData/hydra diff --git a/hydra-kernel.cabal b/hydra-kernel.cabal --- a/hydra-kernel.cabal +++ b/hydra-kernel.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: hydra-kernel -version: 0.16.0 +version: 0.16.1 synopsis: The Hydra kernel: core types, terms, inference, and DSL runtime description: Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". This package is the Hydra kernel: the core type and term model, type inference, the term rewriting and reduction engine, the primitive library, and the DSL runtime — the code that must be present in every Hydra implementation. The convenient entry point is the Hydra.Kernel module, which re-exports the kernel's collision-free surface. category: Data @@ -18,6 +18,7 @@ build-type: Simple extra-source-files: LICENSE + NOTICE CHANGELOG.md source-repository head @@ -42,6 +43,7 @@ Hydra.Decode.Core Hydra.Decode.Error.Checking Hydra.Decode.Error.Core + Hydra.Decode.Error.Packaging Hydra.Decode.Errors Hydra.Decode.Json.Model Hydra.Decode.Packaging @@ -55,30 +57,66 @@ Hydra.Decode.Typed Hydra.Decode.Typing Hydra.Decode.Util + Hydra.Decode.Validation Hydra.Decode.Variants + Hydra.Decode.Yaml.Model Hydra.Decoding Hydra.Dependencies Hydra.Differentiation + Hydra.Dsl.Annotations Hydra.Dsl.Ast + Hydra.Dsl.AsTerm + Hydra.Dsl.AsType + Hydra.Dsl.Bootstrap Hydra.Dsl.Coders Hydra.Dsl.Core + Hydra.Dsl.Deep.Lib.Math Hydra.Dsl.Error.Checking Hydra.Dsl.Error.Core Hydra.Dsl.Error.Packaging Hydra.Dsl.Errors Hydra.Dsl.Graph Hydra.Dsl.Json.Model + Hydra.Dsl.Libraries Hydra.Dsl.Literals + Hydra.Dsl.LiteralTypes + Hydra.Dsl.Meta.Base Hydra.Dsl.Meta.Common + Hydra.Dsl.Meta.Core + Hydra.Dsl.Meta.DeepCore + Hydra.Dsl.Meta.Graph + Hydra.Dsl.Meta.Lib.Chars + Hydra.Dsl.Meta.Lib.Eithers + Hydra.Dsl.Meta.Lib.Equality + Hydra.Dsl.Meta.Lib.Lists + Hydra.Dsl.Meta.Lib.Literals + Hydra.Dsl.Meta.Lib.Logic + Hydra.Dsl.Meta.Lib.Maps + Hydra.Dsl.Meta.Lib.Math + Hydra.Dsl.Meta.Lib.Optionals + Hydra.Dsl.Meta.Lib.Pairs + Hydra.Dsl.Meta.Lib.Regex + Hydra.Dsl.Meta.Lib.Sets + Hydra.Dsl.Meta.Lib.Strings + Hydra.Dsl.Meta.Literals + Hydra.Dsl.Meta.Phantoms + Hydra.Dsl.Meta.Tabular + Hydra.Dsl.Meta.Terms + Hydra.Dsl.Meta.Testing + Hydra.Dsl.Meta.Types + Hydra.Dsl.Meta.Variants Hydra.Dsl.Packaging Hydra.Dsl.Parsing Hydra.Dsl.Paths + Hydra.Dsl.Prims Hydra.Dsl.Query Hydra.Dsl.Relational Hydra.Dsl.Tabular Hydra.Dsl.Terms Hydra.Dsl.Testing + Hydra.Dsl.Tests Hydra.Dsl.Topology + Hydra.Dsl.Types Hydra.Dsl.Typing Hydra.Dsl.Util Hydra.Dsl.Validation @@ -90,6 +128,7 @@ Hydra.Encode.Core Hydra.Encode.Error.Checking Hydra.Encode.Error.Core + Hydra.Encode.Error.Packaging Hydra.Encode.Errors Hydra.Encode.Json.Model Hydra.Encode.Packaging @@ -103,7 +142,9 @@ Hydra.Encode.Typed Hydra.Encode.Typing Hydra.Encode.Util + Hydra.Encode.Validation Hydra.Encode.Variants + Hydra.Encode.Yaml.Model Hydra.Encoding Hydra.Environment Hydra.Error.Checking @@ -181,48 +222,6 @@ Hydra.Show.Util Hydra.Show.Variants Hydra.Sorting - Hydra.Sources.Decode.Ast - Hydra.Sources.Decode.Coders - Hydra.Sources.Decode.Core - Hydra.Sources.Decode.Error.Checking - Hydra.Sources.Decode.Error.Core - Hydra.Sources.Decode.Error.Packaging - Hydra.Sources.Decode.Errors - Hydra.Sources.Decode.Json.Model - Hydra.Sources.Decode.Packaging - Hydra.Sources.Decode.Parsing - Hydra.Sources.Decode.Paths - Hydra.Sources.Decode.Query - Hydra.Sources.Decode.Relational - Hydra.Sources.Decode.Tabular - Hydra.Sources.Decode.Testing - Hydra.Sources.Decode.Topology - Hydra.Sources.Decode.Typed - Hydra.Sources.Decode.Typing - Hydra.Sources.Decode.Util - Hydra.Sources.Decode.Validation - Hydra.Sources.Decode.Variants - Hydra.Sources.Encode.Ast - Hydra.Sources.Encode.Coders - Hydra.Sources.Encode.Core - Hydra.Sources.Encode.Error.Checking - Hydra.Sources.Encode.Error.Core - Hydra.Sources.Encode.Error.Packaging - Hydra.Sources.Encode.Errors - Hydra.Sources.Encode.Json.Model - Hydra.Sources.Encode.Packaging - Hydra.Sources.Encode.Parsing - Hydra.Sources.Encode.Paths - Hydra.Sources.Encode.Query - Hydra.Sources.Encode.Relational - Hydra.Sources.Encode.Tabular - Hydra.Sources.Encode.Testing - Hydra.Sources.Encode.Topology - Hydra.Sources.Encode.Typed - Hydra.Sources.Encode.Typing - Hydra.Sources.Encode.Util - Hydra.Sources.Encode.Validation - Hydra.Sources.Encode.Variants Hydra.Strip Hydra.Substitution Hydra.Tabular diff --git a/src/main/haskell/Hydra/Checking.hs b/src/main/haskell/Hydra/Checking.hs --- a/src/main/haskell/Hydra/Checking.hs +++ b/src/main/haskell/Hydra/Checking.hs @@ -62,7 +62,7 @@ t = Pairs.second uc in (Lists.foldl (\b -> \x -> Logic.and b (Equality.equal x h)) True t)) -- | Apply type arguments to a type, substituting forall-bound variables -applyTypeArgumentsToType :: t0 -> Graph.Graph -> [Core.Type] -> Core.Type -> Either Errors.Error Core.Type +applyTypeArgumentsToType :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Type -> Either Errors.Error Core.Type applyTypeArgumentsToType cx tx typeArgs t = Optionals.cases (Lists.uncons typeArgs) (Right t) (\uc -> let ah = Pairs.first uc @@ -72,6 +72,19 @@ let v = Core.forallTypeParameter v0 tbody = Core.forallTypeBody v0 in (applyTypeArgumentsToType cx tx at (Substitution.substInType (Typing.TypeSubst (Maps.singleton v ah)) tbody)) + Core.TypeVariable v0 -> Eithers.either (\_ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { + Errors.unexpectedShapeErrorExpected = "forall type", + Errors.unexpectedShapeErrorActual = (Strings.cat [ + ShowCore.type_ t, + ". Trying to apply ", + (Literals.showInt32 (Lists.length typeArgs)), + " type args: ", + (Formatting.showList ShowCore.type_ typeArgs)])})))) (\schemaRes -> + let schemaType = Pairs.first schemaRes + schemaBody = Strip.deannotateType (Core.typeSchemeBody schemaType) + in case schemaBody of + Core.TypeForall _ -> applyTypeArgumentsToType cx tx typeArgs schemaBody + _ -> Right t) (Resolution.requireSchemaType cx (Graph.graphSchemaTypes tx) v0) _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { Errors.unexpectedShapeErrorExpected = "forall type", Errors.unexpectedShapeErrorActual = (Strings.cat [ @@ -420,7 +433,7 @@ cx2 = Pairs.second foldR in (Eithers.bind (checkSameType cx2 tx "list elements" eltypes) (\unifiedType -> Right (Core.TypeList unifiedType, cx2))))))) -- | Reconstruct the type of a literal (Either/InferenceContext version) -typeOfLiteral :: t0 -> Graph.Graph -> [Core.Type] -> Core.Literal -> Either Errors.Error (Core.Type, t0) +typeOfLiteral :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Literal -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfLiteral cx tx typeArgs lit = let t = Core.TypeLiteral (Reflect.literalType lit) @@ -626,7 +639,7 @@ Core.forallTypeParameter = v, Core.forallTypeBody = t1}))) (\applied -> Right (applied, cx2))))) -- | Reconstruct the type of the unit term (Either/InferenceContext version) -typeOfUnit :: t0 -> Graph.Graph -> [Core.Type] -> Either Errors.Error (Core.Type, t0) +typeOfUnit :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfUnit cx tx typeArgs = Eithers.bind (applyTypeArgumentsToType cx tx typeArgs Core.TypeUnit) (\applied -> Right (applied, cx)) -- | Reconstruct the type of an unwrap operation (Either/InferenceContext version) @@ -649,15 +662,16 @@ typeOfVariable :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Name -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfVariable cx tx typeArgs name = - let rawTypeScheme = Maps.lookup name (Graph.graphBoundTypes tx) - forScheme = - \ts -> - let tResult = - Logic.ifElse (Lists.null typeArgs) (Resolution.instantiateType cx (Scoping.typeSchemeToFType ts)) (Scoping.typeSchemeToFType ts, cx) - t = Pairs.first tResult - cx2 = Pairs.second tResult - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2))) - in (Optionals.cases rawTypeScheme (Optionals.cases (Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))) (Left (Errors.ErrorUntypedTermVariable (ErrorCore.UntypedTermVariableError { + let forScheme = + \ts -> + let tResult = + Logic.ifElse (Lists.null typeArgs) (Resolution.instantiateType cx (Scoping.typeSchemeToFType ts)) (Scoping.typeSchemeToFType ts, cx) + t = Pairs.first tResult + cx2 = Pairs.second tResult + in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2))) + primScheme = + Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx)) + in (Optionals.cases primScheme (Optionals.cases (Maps.lookup name (Graph.graphBoundTypes tx)) (Left (Errors.ErrorUntypedTermVariable (ErrorCore.UntypedTermVariableError { ErrorCore.untypedTermVariableErrorLocation = (Paths.SubtermPath []), ErrorCore.untypedTermVariableErrorName = name}))) forScheme) forScheme) -- | Reconstruct the type of a wrapped term (Either/InferenceContext version) diff --git a/src/main/haskell/Hydra/Codegen.hs b/src/main/haskell/Hydra/Codegen.hs --- a/src/main/haskell/Hydra/Codegen.hs +++ b/src/main/haskell/Hydra/Codegen.hs @@ -265,7 +265,8 @@ Packaging.DefinitionPrimitive v0 -> Just (Packaging.DefinitionPrimitive v0)) (Packaging.moduleDefinitions m)))} allBindings = Lexical.graphToBindings g1 refreshedMods = Lists.map (\m -> refreshModule allBindings m) termModulesToGenerate - dedupDefs = \defs -> Maps.elems (Maps.fromList (Lists.map (\d -> (Packaging.termDefinitionName d, d)) defs)) + dedupDefs = + \defs -> Lists.sortOn (\d -> Packaging.termDefinitionName d) (Maps.elems (Maps.fromList (Lists.map (\d -> (Packaging.termDefinitionName d, d)) defs))) dedupedDefLists = Lists.map dedupDefs defLists in (Eithers.map (\xs -> Lists.concat xs) (Eithers.mapList (\p -> let mod = Pairs.first p diff --git a/src/main/haskell/Hydra/Decode/Error/Packaging.hs b/src/main/haskell/Hydra/Decode/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Error/Packaging.hs @@ -0,0 +1,185 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term decoders for hydra.error.packaging + +module Hydra.Decode.Error.Packaging where +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Decode.Packaging as DecodePackaging +import qualified Hydra.Decode.Util as DecodeUtil +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.Graph as Graph +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Haskell.Lib.Maps as Maps +import qualified Hydra.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Util as Util +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Decoder for hydra.error.packaging.ConflictingModuleNameError +conflictingModuleNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.ConflictingModuleNameError +conflictingModuleNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "first" DecodePackaging.moduleName fieldMap cx) (\field_first -> Eithers.bind (ExtractCore.requireField "second" DecodePackaging.moduleName fieldMap cx) (\field_second -> Right (ErrorPackaging.ConflictingModuleNameError { + ErrorPackaging.conflictingModuleNameErrorFirst = field_first, + ErrorPackaging.conflictingModuleNameErrorSecond = field_second})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.ConflictingModuleNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.ConflictingVariantNameError +conflictingVariantNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.ConflictingVariantNameError +conflictingVariantNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "typeName" DecodeCore.name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "variantName" DecodeCore.name fieldMap cx) (\field_variantName -> Eithers.bind (ExtractCore.requireField "conflictingName" DecodeCore.name fieldMap cx) (\field_conflictingName -> Right (ErrorPackaging.ConflictingVariantNameError { + ErrorPackaging.conflictingVariantNameErrorModuleName = field_moduleName, + ErrorPackaging.conflictingVariantNameErrorTypeName = field_typeName, + ErrorPackaging.conflictingVariantNameErrorVariantName = field_variantName, + ErrorPackaging.conflictingVariantNameErrorConflictingName = field_conflictingName})))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.ConflictingVariantNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.DefinitionNotInModuleNameError +definitionNotInModuleNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.DefinitionNotInModuleNameError +definitionNotInModuleNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorPackaging.DefinitionNotInModuleNameError { + ErrorPackaging.definitionNotInModuleNameErrorModuleName = field_moduleName, + ErrorPackaging.definitionNotInModuleNameErrorName = field_name})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.DefinitionNotInModuleNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.DefinitionsOutOfOrderError +definitionsOutOfOrderError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.DefinitionsOutOfOrderError +definitionsOutOfOrderError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "precedingName" DecodeCore.name fieldMap cx) (\field_precedingName -> Eithers.bind (ExtractCore.requireField "followingName" DecodeCore.name fieldMap cx) (\field_followingName -> Right (ErrorPackaging.DefinitionsOutOfOrderError { + ErrorPackaging.definitionsOutOfOrderErrorModuleName = field_moduleName, + ErrorPackaging.definitionsOutOfOrderErrorPrecedingName = field_precedingName, + ErrorPackaging.definitionsOutOfOrderErrorFollowingName = field_followingName}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.DefinitionsOutOfOrderError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.DuplicateDefinitionNameError +duplicateDefinitionNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.DuplicateDefinitionNameError +duplicateDefinitionNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorPackaging.DuplicateDefinitionNameError { + ErrorPackaging.duplicateDefinitionNameErrorModuleName = field_moduleName, + ErrorPackaging.duplicateDefinitionNameErrorName = field_name})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.DuplicateDefinitionNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.DuplicateModuleNameError +duplicateModuleNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.DuplicateModuleNameError +duplicateModuleNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Right (ErrorPackaging.DuplicateModuleNameError { + ErrorPackaging.duplicateModuleNameErrorModuleName = field_moduleName}))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.DuplicateModuleNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.InvalidDefinitionNameError +invalidDefinitionNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.InvalidDefinitionNameError +invalidDefinitionNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "expectedConvention" DecodeUtil.caseConvention fieldMap cx) (\field_expectedConvention -> Right (ErrorPackaging.InvalidDefinitionNameError { + ErrorPackaging.invalidDefinitionNameErrorModuleName = field_moduleName, + ErrorPackaging.invalidDefinitionNameErrorName = field_name, + ErrorPackaging.invalidDefinitionNameErrorExpectedConvention = field_expectedConvention}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.InvalidDefinitionNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.InvalidModuleError +invalidModuleError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.InvalidModuleError +invalidModuleError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermInject v0 -> + let field = Core.injectionField v0 + fname = Core.fieldName field + fterm = Core.fieldTerm field + variantMap = + Maps.fromList [ + ( + Core.Name "conflictingVariantName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorConflictingVariantName t) (conflictingVariantNameError cx input))), + ( + Core.Name "definitionNotInModuleName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorDefinitionNotInModuleName t) (definitionNotInModuleNameError cx input))), + ( + Core.Name "definitionsOutOfOrder", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorDefinitionsOutOfOrder t) (definitionsOutOfOrderError cx input))), + ( + Core.Name "duplicateDefinitionName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorDuplicateDefinitionName t) (duplicateDefinitionNameError cx input))), + ( + Core.Name "invalidDefinitionName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorInvalidDefinitionName t) (invalidDefinitionNameError cx input))), + ( + Core.Name "invalidModuleNameConvention", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorInvalidModuleNameConvention t) (invalidModuleNameConventionError cx input))), + ( + Core.Name "missingDocumentation", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorMissingDocumentation t) (missingDocumentationError cx input)))] + in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [ + "no such field ", + (Core.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.InvalidModuleNameConventionError +invalidModuleNameConventionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.InvalidModuleNameConventionError +invalidModuleNameConventionError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Right (ErrorPackaging.InvalidModuleNameConventionError { + ErrorPackaging.invalidModuleNameConventionErrorModuleName = field_moduleName}))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.InvalidModuleNameConventionError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.InvalidPackageError +invalidPackageError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.InvalidPackageError +invalidPackageError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermInject v0 -> + let field = Core.injectionField v0 + fname = Core.fieldName field + fterm = Core.fieldTerm field + variantMap = + Maps.fromList [ + ( + Core.Name "conflictingModuleName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorConflictingModuleName t) (conflictingModuleNameError cx input))), + ( + Core.Name "duplicateModuleName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorDuplicateModuleName t) (duplicateModuleNameError cx input))), + ( + Core.Name "invalidModule", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidModule t) (invalidModuleError cx input))), + ( + Core.Name "invalidPackageName", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input)))] + in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [ + "no such field ", + (Core.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.InvalidPackageNameError +invalidPackageNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.InvalidPackageNameError +invalidPackageNameError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "packageName" DecodePackaging.packageName fieldMap cx) (\field_packageName -> Right (ErrorPackaging.InvalidPackageNameError { + ErrorPackaging.invalidPackageNameErrorPackageName = field_packageName}))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.InvalidPackageNameError")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.error.packaging.MissingDocumentationError +missingDocumentationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.MissingDocumentationError +missingDocumentationError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorPackaging.MissingDocumentationError { + ErrorPackaging.missingDocumentationErrorModuleName = field_moduleName, + ErrorPackaging.missingDocumentationErrorName = field_name})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.MissingDocumentationError")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Parsing.hs b/src/main/haskell/Hydra/Decode/Parsing.hs --- a/src/main/haskell/Hydra/Decode/Parsing.hs +++ b/src/main/haskell/Hydra/Decode/Parsing.hs @@ -36,7 +36,7 @@ Parsing.parseErrorRemainder = field_remainder})))) _ -> Left (Errors.DecodingError "expected a record of type hydra.parsing.ParseError")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.parsing.ParseResult -parseResult :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseResult t0) +parseResult :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseResult a) parseResult a cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermInject v0 -> @@ -53,7 +53,7 @@ " in union"]))) (\f -> f fterm)) _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.parsing.ParseSuccess -parseSuccess :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess t0) +parseSuccess :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess a) parseSuccess a cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> diff --git a/src/main/haskell/Hydra/Decode/Relational.hs b/src/main/haskell/Hydra/Decode/Relational.hs --- a/src/main/haskell/Hydra/Decode/Relational.hs +++ b/src/main/haskell/Hydra/Decode/Relational.hs @@ -25,7 +25,7 @@ _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.relational.ColumnSchema -columnSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.ColumnSchema t0) +columnSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.ColumnSchema t) columnSchema t cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> @@ -51,7 +51,7 @@ Core.TermWrap v0 -> Eithers.map (\b -> Relational.PrimaryKey b) (ExtractCore.decodeList columnName cx (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.relational.Relation -relation :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relation t0) +relation :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relation v) relation v cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermWrap v0 -> Eithers.map (\b -> Relational.Relation b) (ExtractCore.decodeList (row v) cx (Core.wrappedTermBody v0)) @@ -67,7 +67,7 @@ _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.relational.RelationSchema -relationSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.RelationSchema t0) +relationSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.RelationSchema t) relationSchema t cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> @@ -79,13 +79,13 @@ Relational.relationSchemaForeignKeys = field_foreignKeys})))))) _ -> Left (Errors.DecodingError "expected a record of type hydra.relational.RelationSchema")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.relational.Relationship -relationship :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relationship t0)) +relationship :: Ord v => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relationship v)) relationship v cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermWrap v0 -> Eithers.map (\b -> Relational.Relationship b) (ExtractCore.decodeSet (ExtractCore.decodeMap columnName v) cx (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.relational.Row -row :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Row t0) +row :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Row v) row v cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermWrap v0 -> Eithers.map (\b -> Relational.Row b) (ExtractCore.decodeList v cx (Core.wrappedTermBody v0)) diff --git a/src/main/haskell/Hydra/Decode/Tabular.hs b/src/main/haskell/Hydra/Decode/Tabular.hs --- a/src/main/haskell/Hydra/Decode/Tabular.hs +++ b/src/main/haskell/Hydra/Decode/Tabular.hs @@ -26,7 +26,7 @@ Tabular.columnTypeType = field_type})))) _ -> Left (Errors.DecodingError "expected a record of type hydra.tabular.ColumnType")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.tabular.DataRow -dataRow :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.DataRow t0) +dataRow :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.DataRow v) dataRow v cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermWrap v0 -> Eithers.map (\b -> Tabular.DataRow b) (ExtractCore.decodeList (ExtractCore.decodeMaybe v) cx (Core.wrappedTermBody v0)) @@ -42,7 +42,7 @@ _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) cx (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.tabular.Table -table :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.Table t0) +table :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.Table v) table v cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> diff --git a/src/main/haskell/Hydra/Decode/Topology.hs b/src/main/haskell/Hydra/Decode/Topology.hs --- a/src/main/haskell/Hydra/Decode/Topology.hs +++ b/src/main/haskell/Hydra/Decode/Topology.hs @@ -16,7 +16,7 @@ import qualified Data.Scientific as Sci import qualified Data.Map as M -- | Decoder for hydra.topology.Graph -graph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError (M.Map Int [Int]) +graph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError (M.Map Topology.Vertex [Topology.Vertex]) graph = ExtractCore.decodeMap vertex (ExtractCore.decodeList vertex) -- | Decoder for hydra.topology.TarjanState tarjanState :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Topology.TarjanState diff --git a/src/main/haskell/Hydra/Decode/Typed.hs b/src/main/haskell/Hydra/Decode/Typed.hs --- a/src/main/haskell/Hydra/Decode/Typed.hs +++ b/src/main/haskell/Hydra/Decode/Typed.hs @@ -15,7 +15,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci -- | Decoder for hydra.typed.TypedBinding -typedBinding :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedBinding t1) +typedBinding :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedBinding a) typedBinding a cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> @@ -25,13 +25,13 @@ Typed.typedBindingTerm = field_term})))) _ -> Left (Errors.DecodingError "expected a record of type hydra.typed.TypedBinding")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.typed.TypedTerm -typedTerm :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTerm t1) +typedTerm :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTerm a) typedTerm a cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermWrap v0 -> Eithers.map (\b -> Typed.TypedTerm b) (DecodeCore.term cx (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.typed.TypedTermDefinition -typedTermDefinition :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTermDefinition t1) +typedTermDefinition :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTermDefinition a) typedTermDefinition a cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> diff --git a/src/main/haskell/Hydra/Decode/Typing.hs b/src/main/haskell/Hydra/Decode/Typing.hs --- a/src/main/haskell/Hydra/Decode/Typing.hs +++ b/src/main/haskell/Hydra/Decode/Typing.hs @@ -16,7 +16,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci -- | Decoder for hydra.typing.FunctionStructure -functionStructure :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typing.FunctionStructure t0) +functionStructure :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError env) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typing.FunctionStructure env) functionStructure env cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> diff --git a/src/main/haskell/Hydra/Decode/Util.hs b/src/main/haskell/Hydra/Decode/Util.hs --- a/src/main/haskell/Hydra/Decode/Util.hs +++ b/src/main/haskell/Hydra/Decode/Util.hs @@ -65,7 +65,7 @@ _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0)) _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) -- | Decoder for hydra.util.ModuleNames -moduleNames :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Util.ModuleNames t0) +moduleNames :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError n) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Util.ModuleNames n) moduleNames n cx raw = Eithers.either (\err -> Left err) (\stripped -> case stripped of Core.TermRecord v0 -> diff --git a/src/main/haskell/Hydra/Decode/Validation.hs b/src/main/haskell/Hydra/Decode/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Validation.hs @@ -0,0 +1,51 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term decoders for hydra.validation + +module Hydra.Decode.Validation where +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Decode.Error.Core as ErrorCore +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.Graph as Graph +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Decoder for hydra.validation.ValidationProfile +validationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Validation.ValidationProfile +validationProfile cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "errorRules" (ExtractCore.decodeSet DecodeCore.name) fieldMap cx) (\field_errorRules -> Eithers.bind (ExtractCore.requireField "warningRules" (ExtractCore.decodeSet DecodeCore.name) fieldMap cx) (\field_warningRules -> Eithers.bind (ExtractCore.requireField "maxErrors" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralInteger v2 -> case v2 of + Core.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_maxErrors -> Eithers.bind (ExtractCore.requireField "maxWarnings" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralInteger v2 -> case v2 of + Core.IntegerValueInt32 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected int32 value") + _ -> Left (Errors.DecodingError "expected int32 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_maxWarnings -> Right (Validation.ValidationProfile { + Validation.validationProfileErrorRules = field_errorRules, + Validation.validationProfileWarningRules = field_warningRules, + Validation.validationProfileMaxErrors = field_maxErrors, + Validation.validationProfileMaxWarnings = field_maxWarnings})))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.validation.ValidationProfile")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.validation.ValidationResult +validationResult :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Validation.ValidationResult e) +validationResult e cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "errors" (ExtractCore.decodeList e) fieldMap cx) (\field_errors -> Eithers.bind (ExtractCore.requireField "warnings" (ExtractCore.decodeList e) fieldMap cx) (\field_warnings -> Right (Validation.ValidationResult { + Validation.validationResultErrors = field_errors, + Validation.validationResultWarnings = field_warnings})))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.validation.ValidationResult")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Yaml/Model.hs b/src/main/haskell/Hydra/Decode/Yaml/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Yaml/Model.hs @@ -0,0 +1,92 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term decoders for hydra.yaml.model + +module Hydra.Decode.Yaml.Model where +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.Graph as Graph +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Haskell.Lib.Maps as Maps +import qualified Hydra.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Util as Util +import qualified Hydra.Yaml.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Decoder for hydra.yaml.model.Node +node :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Model.Node +node cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermInject v0 -> + let field = Core.injectionField v0 + fname = Core.fieldName field + fterm = Core.fieldTerm field + variantMap = + Maps.fromList [ + (Core.Name "mapping", (\input -> Eithers.map (\t -> Model.NodeMapping t) (ExtractCore.decodeMap node node cx input))), + (Core.Name "scalar", (\input -> Eithers.map (\t -> Model.NodeScalar t) (scalar cx input))), + (Core.Name "sequence", (\input -> Eithers.map (\t -> Model.NodeSequence t) (ExtractCore.decodeList node cx input)))] + in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [ + "no such field ", + (Core.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.yaml.model.Scalar +scalar :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Model.Scalar +scalar cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermInject v0 -> + let field = Core.injectionField v0 + fname = Core.fieldName field + fterm = Core.fieldTerm field + variantMap = + Maps.fromList [ + ( + Core.Name "bool", + (\input -> Eithers.map (\t -> Model.ScalarBool t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralBoolean v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected boolean literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))), + ( + Core.Name "decimal", + (\input -> Eithers.map (\t -> Model.ScalarDecimal t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralDecimal v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected decimal literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))), + ( + Core.Name "float", + (\input -> Eithers.map (\t -> Model.ScalarFloat t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralFloat v2 -> case v2 of + Core.FloatValueFloat64 v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected float64 value") + _ -> Left (Errors.DecodingError "expected float64 literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))), + ( + Core.Name "int", + (\input -> Eithers.map (\t -> Model.ScalarInt t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralInteger v2 -> case v2 of + Core.IntegerValueBigint v3 -> Right v3 + _ -> Left (Errors.DecodingError "expected bigint value") + _ -> Left (Errors.DecodingError "expected bigint literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))), + (Core.Name "null", (\input -> Eithers.map (\t -> Model.ScalarNull) (ExtractCore.decodeUnit cx input))), + ( + Core.Name "str", + (\input -> Eithers.map (\t -> Model.ScalarStr t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of + Core.TermLiteral v1 -> case v1 of + Core.LiteralString v2 -> Right v2 + _ -> Left (Errors.DecodingError "expected string literal") + _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))] + in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [ + "no such field ", + (Core.unName fname), + " in union"]))) (\f -> f fterm)) + _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decoding.hs b/src/main/haskell/Hydra/Decoding.hs --- a/src/main/haskell/Hydra/Decoding.hs +++ b/src/main/haskell/Hydra/Decoding.hs @@ -98,1437 +98,2012 @@ decodeBinding :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.DecodingError Core.Binding decodeBinding cx graph b = Eithers.bind (DecodeCore.type_ graph (Core.bindingTerm b)) (\typ -> - let rawBody = decodeTypeNamed (Core.bindingName b) typ - description = - Strings.cat [ - "Decoder for ", - (Core.unName (Core.bindingName b))] - in (Right (Core.Binding { - Core.bindingName = (decodeBindingName (Core.bindingName b)), - Core.bindingTerm = (Annotations.setTermDescription (Just description) rawBody), - Core.bindingTypeScheme = (Just (decoderTypeSchemeNamed (Core.bindingName b) typ))}))) --- | Generate a binding name for a decoder function from a type name -decodeBindingName :: Core.Name -> Core.Name -decodeBindingName n = - - let parts = Strings.splitOn "." (Core.unName n) - localPart = Formatting.decapitalize (Names.localNameOf n) - localResult = Core.Name localPart - in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsUc -> - let tail = Pairs.second nsUc - in (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "decode"] (Lists.concat2 tail [ - localPart]))))))) --- | Generate a decoder for an Either type -decodeEitherType :: Core.EitherType -> Core.Term -decodeEitherType et = - - let leftDecoder = decodeType (Core.eitherTypeLeft et) - rightDecoder = decodeType (Core.eitherTypeRight et) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeEither")), - Core.applicationArgument = leftDecoder})), - Core.applicationArgument = rightDecoder})) --- | Generate a decoder for a polymorphic (forall) type -decodeForallType :: Core.ForallType -> Core.Term -decodeForallType ft = - Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter ft)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (decodeType (Core.forallTypeBody ft))}) --- | Generate a decoder for a list type -decodeListType :: Core.Type -> Core.Term -decodeListType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = elemDecoder})) --- | Generate a decoder for a literal type -decodeLiteralType :: Core.LiteralType -> Core.Term -decodeLiteralType lt = - case lt of - Core.LiteralTypeBinary -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 binary literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "binary"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.LiteralTypeBoolean -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.LiteralTypeDecimal -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 decimal literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "d"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d"))))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeFloat32 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "float32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.FloatTypeFloat64 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "float64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeBigint -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "bigint", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "bigint", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "bigint"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeInt8 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int8", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int8", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int8"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeInt16 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int16", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int16", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int16"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeInt32 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeInt64 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "int64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int64"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeUint8 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint8", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint8", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint8"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeUint16 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint16", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint16", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint16"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeUint32 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.IntegerTypeUint64 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 (Strings.cat [ - "expected ", - "uint64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint64"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) - Core.LiteralTypeString -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) --- | Generate a decoder for a map type -decodeMapType :: Core.MapType -> Core.Term -decodeMapType mt = - - let keyDecoder = decodeType (Core.mapTypeKeys mt) - valDecoder = decodeType (Core.mapTypeValues mt) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = keyDecoder})), - Core.applicationArgument = valDecoder})) --- | Generate a decoder for an optional type -decodeMaybeType :: Core.Type -> Core.Term -decodeMaybeType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = elemDecoder})) --- | Transform a type module into a decoder module -decodeModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (Maybe Packaging.Module) -decodeModule cx graph mod = - Eithers.bind (filterTypeBindings cx graph (Optionals.cat (Lists.map (\d -> case d of - Packaging.DefinitionType v0 -> Just ((\name -> \typ -> - let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type") - dataTerm = - Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (EncodeCore.type_ typ), - Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [ - (Constants.keyType, schemaTerm)]))})) - in Core.Binding { - Core.bindingName = name, - Core.bindingTerm = dataTerm, - Core.bindingTypeScheme = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0))) - _ -> Nothing) (Packaging.moduleDefinitions mod)))) (\typeBindings -> Logic.ifElse (Lists.null typeBindings) (Right Nothing) (Eithers.bind (Eithers.mapList (\b -> Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\x -> x) (decodeBinding cx graph b)) typeBindings) (\decodedBindings -> - let allDecodedDeps = - Lists.nub (Lists.map decodeModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))) - in (Right (Just (Packaging.Module { - Packaging.moduleName = (decodeModuleName (Packaging.moduleName mod)), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just (Strings.cat [ - "Term decoders for ", - (Packaging.unModuleName (Packaging.moduleName mod))])), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = (Lists.map (\ns -> Packaging.ModuleDependency { - Packaging.moduleDependencyModule = ns, - Packaging.moduleDependencyPackage = Nothing}) (Lists.concat2 [ - Packaging.ModuleName "hydra.extract.core", - (Packaging.ModuleName "hydra.lexical"), - (Packaging.ModuleName "hydra.rewriting"), - (Packaging.moduleName mod), - (Packaging.ModuleName "hydra.util")] allDecodedDeps)), - Packaging.moduleDefinitions = (Lists.map (\b -> Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.bindingName b), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Optionals.map Scoping.typeSchemeToTermSignature (Core.bindingTypeScheme b)), - Packaging.termDefinitionBody = (Core.bindingTerm b)})) decodedBindings)})))))) --- | Generate a decoder module name from a source module name -decodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName -decodeModuleName ns = - - let parts = Strings.splitOn "." (Packaging.unModuleName ns) - fallback = Packaging.ModuleName (Packaging.unModuleName ns) - in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [ - "hydra.decode.", - (Strings.intercalate "." (Pairs.second uc))]))) --- | Generate a decoder for a pair type -decodePairType :: Core.PairType -> Core.Term -decodePairType pt = - - let firstDecoder = decodeType (Core.pairTypeFirst pt) - secondDecoder = decodeType (Core.pairTypeSecond pt) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")), - Core.applicationArgument = firstDecoder})), - Core.applicationArgument = secondDecoder})) --- | Generate a decoder for a record type -decodeRecordType :: [Core.FieldType] -> Core.Term -decodeRecordType rt = decodeRecordTypeImpl (Core.Name "unknown") rt --- | Generate a decoder for a record type with a type name -decodeRecordTypeImpl :: Core.Name -> [Core.FieldType] -> Core.Term -decodeRecordTypeImpl tname rt = - - let decodeFieldTerm = - \ft -> 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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))})), - Core.applicationArgument = (decodeType (Core.fieldTypeType ft))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}) - localVarName = - \ft -> Core.Name (Strings.cat [ - "field_", - (Core.unName (Core.fieldTypeName ft))]) - toFieldLambda = - \ft -> \body -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (localVarName ft), - Core.lambdaDomain = Nothing, - Core.lambdaBody = body}) - decodeBody = - Lists.foldl (\acc -> \ft -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")), - Core.applicationArgument = (decodeFieldTerm ft)})), - Core.applicationArgument = (toFieldLambda ft acc)})) (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = (Lists.map (\ft -> Core.Field { - Core.fieldName = (Core.fieldTypeName ft), - Core.fieldTerm = (Core.TermVariable (localVarName ft))}) rt)})))) (Lists.reverse rt) - in (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 (Strings.cat [ - "expected a record of type ", - (Core.unName tname)])))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = decodeBody}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) --- | Generate a decoder for a record type with element name -decodeRecordTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -decodeRecordTypeNamed ename rt = decodeRecordTypeImpl ename rt --- | Generate a decoder for a set type -decodeSetType :: Core.Type -> Core.Term -decodeSetType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")), - Core.applicationArgument = elemDecoder})) --- | Generate a decoder term for a Type -decodeType :: Core.Type -> Core.Term -decodeType typ = - case typ of - Core.TypeAnnotated v0 -> decodeType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> decodeEitherType v0 - Core.TypeForall v0 -> decodeForallType v0 - Core.TypeList v0 -> decodeListType v0 - Core.TypeLiteral v0 -> decodeLiteralType v0 - Core.TypeMap v0 -> decodeMapType v0 - Core.TypeOptional v0 -> decodeMaybeType v0 - Core.TypePair v0 -> decodePairType v0 - Core.TypeRecord v0 -> decodeRecordType v0 - Core.TypeSet v0 -> decodeSetType v0 - Core.TypeUnion v0 -> decodeUnionType v0 - Core.TypeUnit -> decodeUnitType - Core.TypeVoid -> decodeUnitType - Core.TypeWrap v0 -> decodeWrappedType v0 - Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) - _ -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))}))))}))}) --- | Generate a decoder term for a Type, with element name for nominal types -decodeTypeNamed :: Core.Name -> Core.Type -> Core.Term -decodeTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> decodeTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> decodeEitherType v0 - Core.TypeForall v0 -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter v0)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (decodeTypeNamed ename (Core.forallTypeBody v0))}) - Core.TypeList v0 -> decodeListType v0 - Core.TypeLiteral v0 -> decodeLiteralType v0 - Core.TypeMap v0 -> decodeMapType v0 - Core.TypeOptional v0 -> decodeMaybeType v0 - Core.TypePair v0 -> decodePairType v0 - Core.TypeRecord v0 -> decodeRecordTypeNamed ename v0 - Core.TypeSet v0 -> decodeSetType v0 - Core.TypeUnion v0 -> decodeUnionTypeNamed ename v0 - Core.TypeUnit -> decodeUnitType - Core.TypeVoid -> decodeUnitType - Core.TypeWrap v0 -> decodeWrappedTypeNamed ename v0 - Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) - _ -> Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))}))))}))}) --- | Generate a decoder for a union type -decodeUnionType :: [Core.FieldType] -> Core.Term -decodeUnionType rt = decodeUnionTypeNamed (Core.Name "unknown") rt --- | Generate a decoder for a union type with the given element name -decodeUnionTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -decodeUnionTypeNamed ename rt = - - let toVariantPair = - \ft -> Core.TermPair ( - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = ename, - Core.injectionField = Core.Field { - Core.fieldName = (Core.fieldTypeName ft), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.fieldTypeType ft)), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))) - in (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), - Core.applicationArgument = (Core.TermList (Lists.map toVariantPair rt))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) --- | Generate a decoder for the unit type -decodeUnitType :: Core.Term -decodeUnitType = - Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))}) --- | Generate a decoder for a wrapped type -decodeWrappedType :: Core.Type -> Core.Term -decodeWrappedType wt = decodeWrappedTypeNamed (Core.Name "unknown") wt --- | Generate a decoder for a wrapped type with the given element name -decodeWrappedTypeNamed :: Core.Name -> Core.Type -> Core.Term -decodeWrappedTypeNamed ename wt = - - let bodyDecoder = decodeType wt - in (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = ename, - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = bodyDecoder, - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) --- | Get full result type for decoder -decoderFullResultType :: Core.Type -> Core.Type -decoderFullResultType typ = - case typ of - Core.TypeAnnotated v0 -> decoderFullResultType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (decoderFullResultType (Core.mapTypeKeys v0)), - Core.mapTypeValues = (decoderFullResultType (Core.mapTypeValues v0))}) - Core.TypeOptional v0 -> Core.TypeOptional (decoderFullResultType v0) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (decoderFullResultType (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (decoderFullResultType (Core.pairTypeSecond v0))}) - Core.TypeRecord _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeSet v0 -> Core.TypeSet (decoderFullResultType v0) - Core.TypeUnion _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - _ -> Core.TypeVariable (Core.Name "hydra.core.Term") --- | Get full result type for decoder with element name -decoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type -decoderFullResultTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> decoderFullResultTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultTypeNamed ename (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeRecord _ -> Core.TypeVariable ename - Core.TypeUnion _ -> Core.TypeVariable ename - Core.TypeWrap _ -> Core.TypeVariable ename - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") + let rtype = decoderFullResultTypeNamed (Core.bindingName b) typ + rawBody = decodeTypeNamed (Core.bindingName b) typ rtype + description = + Strings.cat [ + "Decoder for ", + (Core.unName (Core.bindingName b))] + in (Right (Core.Binding { + Core.bindingName = (decodeBindingName (Core.bindingName b)), + Core.bindingTerm = (Annotations.setTermDescription (Just description) rawBody), + Core.bindingTypeScheme = (Just (decoderTypeSchemeNamed (Core.bindingName b) typ))}))) +-- | Generate a binding name for a decoder function from a type name +decodeBindingName :: Core.Name -> Core.Name +decodeBindingName n = + + let parts = Strings.splitOn "." (Core.unName n) + localPart = Formatting.decapitalize (Names.localNameOf n) + localResult = Core.Name localPart + in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsUc -> + let tail = Pairs.second nsUc + in (Core.Name (Strings.intercalate "." (Lists.concat2 [ + "hydra", + "decode"] (Lists.concat2 tail [ + localPart]))))))) +-- | Generate a decoder for an Either type +decodeEitherType :: Core.EitherType -> Core.Term +decodeEitherType et = + + let leftDecoder = decodeType (Core.eitherTypeLeft et) + rightDecoder = decodeType (Core.eitherTypeRight et) + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodeEither")), + Core.typeApplicationTermType = (decoderFullResultType (Core.eitherTypeLeft et))})), + Core.typeApplicationTermType = (decoderFullResultType (Core.eitherTypeRight et))})), + Core.applicationArgument = leftDecoder})), + Core.applicationArgument = rightDecoder})) +-- | Generate a decoder for a polymorphic (forall) type +decodeForallType :: Core.ForallType -> Core.Term +decodeForallType ft = + Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter ft)), + Core.lambdaDomain = (Just (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.forallTypeParameter ft))}))}))}))), + Core.lambdaBody = (decodeType (Core.forallTypeBody ft))}) +-- | Generate a decoder for a list type +decodeListType :: Core.Type -> Core.Term +decodeListType elemType = + + let elemDecoder = decodeType elemType + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), + Core.typeApplicationTermType = (decoderFullResultType elemType)})), + Core.applicationArgument = elemDecoder})) +-- | Generate a decoder for a literal type +decodeLiteralType :: Core.LiteralType -> Core.Term +decodeLiteralType lt = + case lt of + Core.LiteralTypeBinary -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral Core.LiteralTypeBinary)}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBinary)}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBinary)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected binary literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBinary)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "binary"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "b"), + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeBinary)), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBinary)}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.LiteralTypeBoolean -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral Core.LiteralTypeBoolean)}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBoolean)}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBoolean)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBoolean)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "boolean"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "b"), + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeBoolean)), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeBoolean)}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.LiteralTypeDecimal -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral Core.LiteralTypeDecimal)}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeDecimal)}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeDecimal)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected decimal literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeDecimal)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "decimal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "d"), + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeDecimal)), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeDecimal)}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.LiteralTypeFloat v0 -> case v0 of + Core.FloatTypeFloat32 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "float32", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "float"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "float32", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "float32"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeFloat v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.FloatTypeFloat64 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "float64", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "float"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "float64", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "float64"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeFloat v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeFloat v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.LiteralTypeInteger v0 -> case v0 of + Core.IntegerTypeBigint -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "bigint", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "bigint", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "bigint"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeInt8 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int8", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int8", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "int8"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeInt16 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int16", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int16", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "int16"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeInt32 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int32", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int32", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "int32"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeInt64 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int64", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "int64", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "int64"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeUint8 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint8", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint8", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "uint8"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeUint16 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint16", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint16", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "uint16"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeUint32 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint32", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint32", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "uint32"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.IntegerTypeUint64 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint64", + " literal"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "integer"), + Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected ", + "uint64", + " value"])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "uint64"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "i"), + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger v0))}))}))}]}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) + Core.LiteralTypeString -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeLiteral Core.LiteralTypeString)}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "literal"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Literal"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "string"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s"), + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}) +-- | Generate a decoder for a map type +decodeMapType :: Core.MapType -> Core.Term +decodeMapType mt = + + let keyDecoder = decodeType (Core.mapTypeKeys mt) + valDecoder = decodeType (Core.mapTypeValues mt) + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), + Core.typeApplicationTermType = (decoderFullResultType (Core.mapTypeKeys mt))})), + Core.typeApplicationTermType = (decoderFullResultType (Core.mapTypeValues mt))})), + Core.applicationArgument = keyDecoder})), + Core.applicationArgument = valDecoder})) +-- | Generate a decoder for an optional type +decodeMaybeType :: Core.Type -> Core.Term +decodeMaybeType elemType = + + let elemDecoder = decodeType elemType + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), + Core.typeApplicationTermType = (decoderFullResultType elemType)})), + Core.applicationArgument = elemDecoder})) +-- | Transform a type module into a decoder module +decodeModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (Maybe Packaging.Module) +decodeModule cx graph mod = + Eithers.bind (filterTypeBindings cx graph (Optionals.cat (Lists.map (\d -> case d of + Packaging.DefinitionType v0 -> Just ((\name -> \typ -> + let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type") + dataTerm = + Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (EncodeCore.type_ typ), + Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [ + (Constants.keyType, schemaTerm)]))})) + in Core.Binding { + Core.bindingName = name, + Core.bindingTerm = dataTerm, + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), + Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0))) + _ -> Nothing) (Packaging.moduleDefinitions mod)))) (\typeBindings -> Logic.ifElse (Lists.null typeBindings) (Right Nothing) (Eithers.bind (Eithers.mapList (\b -> Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\x -> x) (decodeBinding cx graph b)) typeBindings) (\decodedBindings -> + let allDecodedDeps = + Lists.nub (Lists.map decodeModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))) + in (Right (Just (Packaging.Module { + Packaging.moduleName = (decodeModuleName (Packaging.moduleName mod)), + Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { + Packaging.entityMetadataDescription = (Just (Strings.cat [ + "Term decoders for ", + (Packaging.unModuleName (Packaging.moduleName mod))])), + Packaging.entityMetadataComments = [], + Packaging.entityMetadataSeeAlso = [], + Packaging.entityMetadataLifecycle = Nothing})), + Packaging.moduleDependencies = (Lists.map (\ns -> Packaging.ModuleDependency { + Packaging.moduleDependencyModule = ns, + Packaging.moduleDependencyPackage = Nothing}) (Lists.concat2 [ + Packaging.ModuleName "hydra.extract.core", + (Packaging.ModuleName "hydra.lexical"), + (Packaging.ModuleName "hydra.rewriting"), + (Packaging.moduleName mod), + (Packaging.ModuleName "hydra.util")] allDecodedDeps)), + Packaging.moduleDefinitions = (Lists.map (\b -> Packaging.DefinitionTerm (Packaging.TermDefinition { + Packaging.termDefinitionName = (Core.bindingName b), + Packaging.termDefinitionMetadata = Nothing, + Packaging.termDefinitionSignature = (Optionals.map Scoping.typeSchemeToTermSignature (Core.bindingTypeScheme b)), + Packaging.termDefinitionBody = (Core.bindingTerm b)})) decodedBindings)})))))) +-- | Generate a decoder module name from a source module name +decodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName +decodeModuleName ns = + + let parts = Strings.splitOn "." (Packaging.unModuleName ns) + fallback = Packaging.ModuleName (Packaging.unModuleName ns) + in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [ + "hydra.decode.", + (Strings.intercalate "." (Pairs.second uc))]))) +-- | Generate a decoder for a pair type +decodePairType :: Core.PairType -> Core.Term +decodePairType pt = + + let firstDecoder = decodeType (Core.pairTypeFirst pt) + secondDecoder = decodeType (Core.pairTypeSecond pt) + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")), + Core.typeApplicationTermType = (decoderFullResultType (Core.pairTypeFirst pt))})), + Core.typeApplicationTermType = (decoderFullResultType (Core.pairTypeSecond pt))})), + Core.applicationArgument = firstDecoder})), + Core.applicationArgument = secondDecoder})) +-- | Generate a decoder for a record type +decodeRecordType :: [Core.FieldType] -> Core.Term +decodeRecordType rt = decodeRecordTypeImpl (Core.Name "unknown") rt (Core.TypeVariable (Core.Name "unknown")) +-- | Generate a decoder for a record type with a type name. rtype is the fully-applied result type (e.g. Table) used for the record's body annotations. (#476) +decodeRecordTypeImpl :: Core.Name -> [Core.FieldType] -> Core.Type -> Core.Term +decodeRecordTypeImpl tname rt rtype = + + let recType = rtype + graphType = Core.TypeVariable (Core.Name "hydra.graph.Graph") + termType = Core.TypeVariable (Core.Name "hydra.core.Term") + decodeFieldTerm = + \ft -> 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.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")), + Core.typeApplicationTermType = graphType})), + Core.typeApplicationTermType = termType})), + Core.typeApplicationTermType = (decoderFullResultType (Core.fieldTypeType ft))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))})), + Core.applicationArgument = (decodeType (Core.fieldTypeType ft))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}) + localVarName = + \ft -> Core.Name (Strings.cat [ + "field_", + (Core.unName (Core.fieldTypeName ft))]) + toFieldLambda = + \ft -> \body -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (localVarName ft), + Core.lambdaDomain = (Just (decoderFullResultType (Core.fieldTypeType ft))), + Core.lambdaBody = body}) + decodeBody = + Lists.foldl (\acc -> \ft -> Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (decoderFullResultType (Core.fieldTypeType ft))})), + Core.typeApplicationTermType = recType})), + Core.applicationArgument = (decodeFieldTerm ft)})), + Core.applicationArgument = (toFieldLambda ft acc)})) (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { + Core.recordTypeName = tname, + Core.recordFields = (Lists.map (\ft -> Core.Field { + Core.fieldName = (Core.fieldTypeName ft), + Core.fieldTerm = (Core.TermVariable (localVarName ft))}) rt)})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = recType})) (Lists.reverse rt) + in (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = recType}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = recType}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ + "expected a record of type ", + (Core.unName tname)])))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = recType}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "record"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "record"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Record"))), + 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.core.toFieldMap")), + Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeMap (Core.MapType { + Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), + Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeSchemeConstraints = Nothing}))}], + Core.letBody = decodeBody}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) +-- | Generate a decoder for a record type with element name +decodeRecordTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Type -> Core.Term +decodeRecordTypeNamed ename rt rtype = decodeRecordTypeImpl ename rt rtype +-- | Generate a decoder for a set type +decodeSetType :: Core.Type -> Core.Term +decodeSetType elemType = + + let elemDecoder = decodeType elemType + in (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")), + Core.typeApplicationTermType = (decoderFullResultType elemType)})), + Core.applicationArgument = elemDecoder})) +-- | Generate a decoder term for a Type +decodeType :: Core.Type -> Core.Term +decodeType typ = + case typ of + Core.TypeAnnotated v0 -> decodeType (Core.annotatedTypeBody v0) + Core.TypeApplication v0 -> Core.TermApplication (Core.Application { + Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), + Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) + Core.TypeEither v0 -> decodeEitherType v0 + Core.TypeForall v0 -> decodeForallType v0 + Core.TypeList v0 -> decodeListType v0 + Core.TypeLiteral v0 -> decodeLiteralType v0 + Core.TypeMap v0 -> decodeMapType v0 + Core.TypeOptional v0 -> decodeMaybeType v0 + Core.TypePair v0 -> decodePairType v0 + Core.TypeRecord v0 -> decodeRecordType v0 + Core.TypeSet v0 -> decodeSetType v0 + Core.TypeUnion v0 -> decodeUnionType v0 + Core.TypeUnit -> decodeUnitType + Core.TypeVoid -> decodeUnitType + Core.TypeWrap v0 -> decodeWrappedType v0 + Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) + _ -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "t"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}) +-- | Generate a decoder term for a Type, with element name for nominal types. rtype is the FULLY-APPLIED result type for nominal bodies (e.g. DataRow for forall v. wrap...), so the body's intermediate type annotations carry the type parameters rather than a bare nominal name — otherwise Java/Scala coders emit raw types that fail to compile against the parameterized signature. (#476) +decodeTypeNamed :: Core.Name -> Core.Type -> Core.Type -> Core.Term +decodeTypeNamed ename typ rtype = + case typ of + Core.TypeAnnotated v0 -> decodeTypeNamed ename (Core.annotatedTypeBody v0) rtype + Core.TypeApplication v0 -> Core.TermApplication (Core.Application { + Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), + Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) + Core.TypeEither v0 -> decodeEitherType v0 + Core.TypeForall v0 -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter v0)), + Core.lambdaDomain = (Just (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.forallTypeParameter v0))}))}))}))), + Core.lambdaBody = (decodeTypeNamed ename (Core.forallTypeBody v0) rtype)}) + Core.TypeList v0 -> decodeListType v0 + Core.TypeLiteral v0 -> decodeLiteralType v0 + Core.TypeMap v0 -> decodeMapType v0 + Core.TypeOptional v0 -> decodeMaybeType v0 + Core.TypePair v0 -> decodePairType v0 + Core.TypeRecord v0 -> decodeRecordTypeNamed ename v0 rtype + Core.TypeSet v0 -> decodeSetType v0 + Core.TypeUnion v0 -> decodeUnionTypeNamed ename v0 rtype + Core.TypeUnit -> decodeUnitType + Core.TypeVoid -> decodeUnitType + Core.TypeWrap v0 -> decodeWrappedTypeNamed ename v0 rtype + Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) + _ -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "t"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}) +-- | Generate a decoder for a union type +decodeUnionType :: [Core.FieldType] -> Core.Term +decodeUnionType rt = decodeUnionTypeNamed (Core.Name "unknown") rt (Core.TypeVariable (Core.Name "unknown")) +-- | Generate a decoder for a union type with the given element name. rtype is the fully-applied result type (e.g. Foo) used for body annotations. (#476) +decodeUnionTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Type -> Core.Term +decodeUnionTypeNamed ename rt rtype = + + let unionType = rtype + decErrType = Core.TypeVariable (Core.Name "hydra.errors.DecodingError") + nameType = Core.TypeVariable (Core.Name "hydra.core.Name") + variantFnType = + Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), + Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = decErrType, + Core.eitherTypeRight = unionType}))}) + toVariantPair = + \ft -> + let fldType = decoderFullResultType (Core.fieldTypeType ft) + in (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermPair ( + Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}), + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "input"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.typeApplicationTermType = fldType})), + Core.typeApplicationTermType = unionType})), + Core.typeApplicationTermType = decErrType})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "t"), + Core.lambdaDomain = (Just fldType), + Core.lambdaBody = (Core.TermInject (Core.Injection { + Core.injectionTypeName = ename, + Core.injectionField = Core.Field { + Core.fieldName = (Core.fieldTypeName ft), + Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (decodeType (Core.fieldTypeType ft)), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Name"))})), + Core.typeApplicationTermType = variantFnType})) + in (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = unionType}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = unionType}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = unionType}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "inject"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "inj"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Injection"))), + Core.lambdaBody = (Core.TermLet (Core.Let { + Core.letBindings = [ + Core.Binding { + Core.bindingName = (Core.Name "field"), + Core.bindingTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.core.Injection"), + Core.projectionFieldName = (Core.Name "field")})), + Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Field")), + Core.typeSchemeConstraints = Nothing}))}, + Core.Binding { + Core.bindingName = (Core.Name "fname"), + Core.bindingTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.core.Field"), + Core.projectionFieldName = (Core.Name "name")})), + Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), + Core.typeSchemeConstraints = Nothing}))}, + Core.Binding { + Core.bindingName = (Core.Name "fterm"), + Core.bindingTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.core.Field"), + Core.projectionFieldName = (Core.Name "term")})), + Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), + Core.typeSchemeConstraints = Nothing}))}, + Core.Binding { + Core.bindingName = (Core.Name "variantMap"), + Core.bindingTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.typeApplicationTermType = nameType})), + Core.typeApplicationTermType = variantFnType})), + Core.applicationArgument = (Core.TermList (Lists.map toVariantPair rt))})), + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeMap (Core.MapType { + Core.mapTypeKeys = nameType, + Core.mapTypeValues = variantFnType})), + Core.typeSchemeConstraints = Nothing}))}], + Core.letBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.typeApplicationTermType = variantFnType})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = decErrType, + Core.eitherTypeRight = unionType}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), + Core.typeApplicationTermType = nameType})), + Core.typeApplicationTermType = variantFnType})), + Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), + Core.applicationArgument = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")), + Core.applicationArgument = (Core.TermList [ + Core.TermLiteral (Core.LiteralString "no such field "), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), + Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), + (Core.TermLiteral (Core.LiteralString " in union"))])}))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = unionType}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = (Just variantFnType), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})), + 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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) +-- | Generate a decoder for the unit type +decodeUnitType :: Core.Term +decodeUnitType = + Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "t"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))}) +-- | Generate a decoder for a wrapped type +decodeWrappedType :: Core.Type -> Core.Term +decodeWrappedType wt = decodeWrappedTypeNamed (Core.Name "unknown") wt (Core.TypeVariable (Core.Name "unknown")) +-- | Generate a decoder for a wrapped type with the given element name. rtype is the fully-applied result type (e.g. DataRow) used for body annotations. (#476) +decodeWrappedTypeNamed :: Core.Name -> Core.Type -> Core.Type -> Core.Term +decodeWrappedTypeNamed ename wt rtype = + + let bodyDecoder = decodeType wt + bodyType = decoderFullResultType wt + in (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "cx"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.graph.Graph"))), + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "raw"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = rtype}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "err"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))), + Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err")))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = rtype}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "stripped"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermCases (Core.CaseStatement { + Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), + Core.caseStatementDefault = (Just (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))})))), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.typeApplicationTermType = rtype}))), + Core.caseStatementCases = [ + Core.CaseAlternative { + Core.caseAlternativeName = (Core.Name "wrap"), + Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "wrappedTerm"), + Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm"))), + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.typeApplicationTermType = bodyType})), + Core.typeApplicationTermType = rtype})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "b"), + Core.lambdaDomain = (Just bodyType), + Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = ename, + Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = bodyDecoder, + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), + Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), + Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})) +-- | Get full result type for decoder +decoderFullResultType :: Core.Type -> Core.Type +decoderFullResultType typ = + case typ of + Core.TypeAnnotated v0 -> decoderFullResultType (Core.annotatedTypeBody v0) + Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), + Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) + Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), + Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) + Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (decoderFullResultType (Core.forallTypeBody v0)), + Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) + Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) + Core.TypeLiteral v0 -> Core.TypeLiteral v0 + Core.TypeMap v0 -> Core.TypeMap (Core.MapType { + Core.mapTypeKeys = (decoderFullResultType (Core.mapTypeKeys v0)), + Core.mapTypeValues = (decoderFullResultType (Core.mapTypeValues v0))}) + Core.TypeOptional v0 -> Core.TypeOptional (decoderFullResultType v0) + Core.TypePair v0 -> Core.TypePair (Core.PairType { + Core.pairTypeFirst = (decoderFullResultType (Core.pairTypeFirst v0)), + Core.pairTypeSecond = (decoderFullResultType (Core.pairTypeSecond v0))}) + Core.TypeRecord _ -> Core.TypeVariable (Core.Name "hydra.core.Term") + Core.TypeSet v0 -> Core.TypeSet (decoderFullResultType v0) + Core.TypeUnion _ -> Core.TypeVariable (Core.Name "hydra.core.Term") + Core.TypeUnit -> Core.TypeUnit + Core.TypeVariable v0 -> Core.TypeVariable v0 + Core.TypeVoid -> Core.TypeVoid + Core.TypeWrap v0 -> decoderFullResultType v0 + _ -> Core.TypeVariable (Core.Name "hydra.core.Term") +-- | Get full result type for decoder with element name +decoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type +decoderFullResultTypeNamed ename typ = + case typ of + Core.TypeAnnotated v0 -> decoderFullResultTypeNamed ename (Core.annotatedTypeBody v0) + Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (decoderFullResultTypeNamed ename (Core.forallTypeBody v0)), + Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) + Core.TypeRecord _ -> Core.TypeVariable ename + Core.TypeUnion _ -> Core.TypeVariable ename + Core.TypeWrap _ -> Core.TypeVariable ename + Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), + Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) + Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), + Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) + Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) + Core.TypeLiteral v0 -> Core.TypeLiteral v0 Core.TypeMap v0 -> Core.TypeMap (Core.MapType { Core.mapTypeKeys = (decoderFullResultType (Core.mapTypeKeys v0)), Core.mapTypeValues = (decoderFullResultType (Core.mapTypeValues v0))}) diff --git a/src/main/haskell/Hydra/Dsl/Annotations.hs b/src/main/haskell/Hydra/Dsl/Annotations.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Annotations.hs @@ -0,0 +1,85 @@ +-- | A DSL which is used as a basis for some of the other DSLs + +module Hydra.Dsl.Annotations where + +import Hydra.Core +import Hydra.Util +import Hydra.Constants +import Hydra.Annotations +import Hydra.Dsl.AsType +import Hydra.Formatting +import Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Types as Types + +import qualified Data.Map as M +import qualified Data.Maybe as Y + + +annotateTerm :: Name -> Y.Maybe Term -> Term -> Term +annotateTerm = setTermAnnotation + +annotateType :: Name -> Y.Maybe Term -> Type -> Type +annotateType = setTypeAnnotation + +bounded :: Maybe Int -> Maybe Int -> Type -> Type +bounded min max = annotMin . annotMax + where + annotMax t = Y.maybe t (`setMaxLength` t) max + annotMin t = Y.maybe t (`setMinLength` t) max + +boundedList :: AsType a => Maybe Int -> Maybe Int -> a -> Type +boundedList min max et = bounded min max $ Types.list (asType et) + +boundedMap :: (AsType a, AsType b) => Maybe Int -> Maybe Int -> a -> b -> Type +boundedMap min max kt vt = bounded min max $ Types.map (asType kt) (asType vt) + +boundedSet :: AsType a => Maybe Int -> Maybe Int -> a -> Type +boundedSet min max et = bounded min max $ Types.set (asType et) + +boundedString :: Maybe Int -> Maybe Int -> Type +boundedString min max = bounded min max Types.string + +dataDoc :: String -> Term -> Term +dataDoc s = setTermDescription (Just s) + +deprecated :: AsType a => a -> Type +deprecated = setTypeAnnotation keyDeprecated (Just $ Terms.boolean True) . asType + +doc :: AsType a => String -> a -> Type +doc s = setTypeDescription (Just s) . asType + +doc70 :: AsType a => String -> a -> Type +doc70 = doc . wrapLine 70 + +doc80 :: AsType a => String -> a -> Type +doc80 = doc . wrapLine 80 + +exclude :: AsType a => a -> Type +exclude = setTypeAnnotation keyExclude (Just $ Terms.boolean True) . asType + +minLengthList :: AsType a => Int -> a -> Type +minLengthList len = boundedList (Just len) Nothing + +nonemptyList :: AsType a => a -> Type +nonemptyList = minLengthList 1 + +nonemptyMap :: (AsType a, AsType b) => a -> b -> Type +nonemptyMap = boundedMap (Just 1) Nothing + +note :: AsType a => String -> a -> Type +note s = doc $ "Note: " ++ s + +preserveFieldName :: AsType a => a -> Type +preserveFieldName = setTypeAnnotation keyPreserveFieldName (Just $ Terms.boolean True) . asType + +see :: AsType a => String -> a -> Type +see s = doc $ "See " ++ s + +setMaxLength :: Int -> Type -> Type +setMaxLength m = setTypeAnnotation keyMaxLength (Just $ Terms.int32 m) + +setMinLength :: Int -> Type -> Type +setMinLength m = setTypeAnnotation keyMinLength (Just $ Terms.int32 m) + +twoOrMoreList :: AsType a => a -> Type +twoOrMoreList = boundedList (Just 2) Nothing diff --git a/src/main/haskell/Hydra/Dsl/AsTerm.hs b/src/main/haskell/Hydra/Dsl/AsTerm.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/AsTerm.hs @@ -0,0 +1,52 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE FunctionalDependencies #-} + +-- | Type class for implicit coercion to TypedTerm +-- This allows TypedTerm, TypedBinding, and String to be used where a TypedTerm is expected, +-- while preserving phantom type information. + +module Hydra.Dsl.AsTerm where + +import Hydra.Core +import Hydra.Packaging +import Hydra.Typed + + +-- | Type class for implicit coercion to TypedTerm, preserving phantom types +-- TypedTerm passes through unchanged, TypedBinding becomes a variable reference +-- The functional dependency ensures that the input type determines the phantom type +class AsTerm f a | f -> a where + asTerm :: f -> TypedTerm a + +instance AsTerm (TypedTerm a) a where + asTerm = id + +instance AsTerm (TypedBinding a) a where + asTerm (TypedBinding name _) = TypedTerm (TermVariable name) + +instance AsTerm (TypedTermDefinition a) a where + asTerm (TypedTermDefinition name _) = TypedTerm (TermVariable name) + +instance AsTerm String String where + asTerm s = TypedTerm $ TermLiteral $ LiteralString s + +instance AsTerm Int Int where + asTerm i = TypedTerm $ TermLiteral $ LiteralInteger $ IntegerValueInt32 i + + +-- | Type class for types from which a kernel-level 'Name' can be statically extracted. +-- Used by Phantoms primitives like 'inject', 'match', 'project', 'record', 'unwrap', 'wrap' +-- to accept either a bare 'Name' or any name-typed binding/definition where the 'Name' +-- is known at construction time. Distinct from 'AsTerm' (which can lift arbitrary +-- @TypedTerm Name@ values, but those don't yield a static 'Name'). +class AsName n where + asName :: n -> Name + +instance AsName Name where + asName = id + +instance AsName (TypedBinding Name) where + asName (TypedBinding name _) = name + +instance AsName (TypedTermDefinition Name) where + asName (TypedTermDefinition name _) = name diff --git a/src/main/haskell/Hydra/Dsl/AsType.hs b/src/main/haskell/Hydra/Dsl/AsType.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/AsType.hs @@ -0,0 +1,25 @@ +{-# LANGUAGE FlexibleInstances #-} + +-- | Type class for implicit coercion to Type +-- This allows Type, TypeDefinition, and String to be used where a Type is expected + +module Hydra.Dsl.AsType where + +import Hydra.Core +import Hydra.Packaging + + +-- | Type class for implicit coercion to Type +-- This allows Type, TypeDefinition, and String to be used where a Type is expected +class AsType a where + asType :: a -> Type + +instance AsType Type where + asType = id + +-- | A TypeDefinition is referenced as a type variable bearing its name. +instance AsType TypeDefinition where + asType = TypeVariable . typeDefinitionName + +instance AsType String where + asType s = TypeVariable (Name s) diff --git a/src/main/haskell/Hydra/Dsl/Bootstrap.hs b/src/main/haskell/Hydra/Dsl/Bootstrap.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Bootstrap.hs @@ -0,0 +1,76 @@ +-- | A bootstrapping DSL, used for Hydra's inner core models + +module Hydra.Dsl.Bootstrap ( + module Hydra.Dsl.AsType, + bootstrapGraph, + datatype, + descriptionMetadata, + qualify, + qualifiedDep, + typeref, + defineType, + unqualifiedDep, +) where + +import Hydra.Util +import Hydra.Constants +import Hydra.Core +import Hydra.Dsl.AsType +import Hydra.Graph +import Hydra.Lexical +import Hydra.Annotations +import Hydra.Packaging +import Hydra.Dsl.Libraries + +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Set as S + + +-- | An empty graph (no elements, no schema, but with primitive functions) which is used for bootstrapping Hydra Core +bootstrapGraph :: Graph +bootstrapGraph = Graph { + graphBoundTerms = M.empty, + graphBoundTypes = M.empty, + graphClassConstraints = M.empty, + graphLambdaVariables = S.empty, + graphMetadata = M.empty, + graphPrimitives = M.fromList $ fmap (\p -> (primitiveDefinitionName (primitiveDefinition p), p)) (L.concat (libraryPrimitives <$> standardLibraries)), + graphSchemaTypes = M.empty, + graphTypeVariables = S.empty} + +-- | Define a type in a namespace, producing a TypeDefinition directly. +datatype :: ModuleName -> String -> Type -> TypeDefinition +datatype gname lname typ = TypeDefinition { + typeDefinitionName = qualify gname (Name lname), + typeDefinitionMetadata = Nothing, + typeDefinitionBody = TypeScheme { + typeSchemeVariables = [], + typeSchemeBody = typ, + typeSchemeConstraints = Nothing}} + +-- | Define a type in a namespace +defineType :: ModuleName -> String -> Type -> TypeDefinition +defineType = datatype + +-- | A module dependency qualified by the providing package, for disambiguation. +-- Not yet used, but retained for forthcoming package-qualified dependency resolution. +qualifiedDep :: PackageName -> ModuleName -> ModuleDependency +qualifiedDep pkg ns = ModuleDependency ns (Just pkg) + +qualify :: ModuleName -> Name -> Name +qualify (ModuleName gname) (Name lname) = Name $ gname ++ "." ++ lname + +typeref :: ModuleName -> String -> Type +typeref ns = TypeVariable . qualify ns . Name + +-- | An unqualified module dependency (package omitted; resolver searches all packages in scope) +unqualifiedDep :: ModuleName -> ModuleDependency +unqualifiedDep ns = ModuleDependency ns Nothing + +-- | Wrap an optional description string as entity metadata carrying only that description. +-- Used to migrate the former Module/Package `description` field into the `metadata` field +-- without data loss; a Nothing description yields no metadata. +descriptionMetadata :: Maybe String -> Maybe EntityMetadata +descriptionMetadata Nothing = Nothing +descriptionMetadata desc = Just (EntityMetadata desc [] [] Nothing) diff --git a/src/main/haskell/Hydra/Dsl/Deep/Lib/Math.hs b/src/main/haskell/Hydra/Dsl/Deep/Lib/Math.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Deep/Lib/Math.hs @@ -0,0 +1,131 @@ +-- | Deep term DSL for the hydra.lib.math library. +-- +-- These helpers construct Term-valued representations of math primitive +-- applications (TypedTerm Term), as opposed to the shallow DSL in +-- Hydra.Dsl.Meta.Lib.Math which works at the Haskell value level (TypedTerm Double, etc.). + +module Hydra.Dsl.Deep.Lib.Math where + +import Hydra.Kernel +import qualified Hydra.Dsl.Meta.Core as Core +import Hydra.Dsl.Meta.Phantoms (encodedName) +import Hydra.Dsl.Terms (ToPrimName(..)) +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Math as DefMath + + +-- | Apply a unary math primitive to a deep term +apply1 :: ToPrimName n => n -> TypedTerm Term -> TypedTerm Term +apply1 n arg = Core.termApplication $ Core.application (Core.termVariable $ encodedName $ toPrimName n) arg + +-- | Apply a binary math primitive to two deep terms +apply2 :: ToPrimName n => n -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term +apply2 n a b = Core.termApplication $ Core.application + (Core.termApplication $ Core.application (Core.termVariable $ encodedName $ toPrimName n) a) + b + +-- | Reference a math primitive as a deep term (for use as a first-class value) +ref :: ToPrimName n => n -> TypedTerm Term +ref = Core.termVariable . encodedName . toPrimName + + +-- Unary functions + +abs :: TypedTerm Term -> TypedTerm Term +abs = apply1 (Prims.primName DefMath.abs) + +acos :: TypedTerm Term -> TypedTerm Term +acos = apply1 (Prims.primName DefMath.acos) + +acosh :: TypedTerm Term -> TypedTerm Term +acosh = apply1 (Prims.primName DefMath.acosh) + +asin :: TypedTerm Term -> TypedTerm Term +asin = apply1 (Prims.primName DefMath.asin) + +asinh :: TypedTerm Term -> TypedTerm Term +asinh = apply1 (Prims.primName DefMath.asinh) + +atan :: TypedTerm Term -> TypedTerm Term +atan = apply1 (Prims.primName DefMath.atan) + +atanh :: TypedTerm Term -> TypedTerm Term +atanh = apply1 (Prims.primName DefMath.atanh) + +ceiling :: TypedTerm Term -> TypedTerm Term +ceiling = apply1 (Prims.primName DefMath.ceiling) + +cos :: TypedTerm Term -> TypedTerm Term +cos = apply1 (Prims.primName DefMath.cos) + +cosh :: TypedTerm Term -> TypedTerm Term +cosh = apply1 (Prims.primName DefMath.cosh) + +exp :: TypedTerm Term -> TypedTerm Term +exp = apply1 (Prims.primName DefMath.exp) + +floor :: TypedTerm Term -> TypedTerm Term +floor = apply1 (Prims.primName DefMath.floor) + +log :: TypedTerm Term -> TypedTerm Term +log = apply1 (Prims.primName DefMath.log) + +negate :: TypedTerm Term -> TypedTerm Term +negate = apply1 (Prims.primName DefMath.negate) + +negateFloat64 :: TypedTerm Term -> TypedTerm Term +negateFloat64 = apply1 (Prims.primName DefMath.negateFloat64) + +round :: TypedTerm Term -> TypedTerm Term +round = apply1 (Prims.primName DefMath.round) + +signum :: TypedTerm Term -> TypedTerm Term +signum = apply1 (Prims.primName DefMath.signum) + +sin :: TypedTerm Term -> TypedTerm Term +sin = apply1 (Prims.primName DefMath.sin) + +sinh :: TypedTerm Term -> TypedTerm Term +sinh = apply1 (Prims.primName DefMath.sinh) + +sqrt :: TypedTerm Term -> TypedTerm Term +sqrt = apply1 (Prims.primName DefMath.sqrt) + +tan :: TypedTerm Term -> TypedTerm Term +tan = apply1 (Prims.primName DefMath.tan) + +tanh :: TypedTerm Term -> TypedTerm Term +tanh = apply1 (Prims.primName DefMath.tanh) + +truncate :: TypedTerm Term -> TypedTerm Term +truncate = apply1 (Prims.primName DefMath.truncate) + + +-- Binary functions + +add :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +add = apply2 (Prims.primName DefMath.add) + +addFloat64 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +addFloat64 = apply2 (Prims.primName DefMath.addFloat64) + +atan2 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +atan2 = apply2 (Prims.primName DefMath.atan2) + +logBase :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +logBase = apply2 (Prims.primName DefMath.logBase) + +mul :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +mul = apply2 (Prims.primName DefMath.mul) + +mulFloat64 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +mulFloat64 = apply2 (Prims.primName DefMath.mulFloat64) + +pow :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +pow = apply2 (Prims.primName DefMath.pow) + +sub :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +sub = apply2 (Prims.primName DefMath.sub) + +subFloat64 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +subFloat64 = apply2 (Prims.primName DefMath.subFloat64) diff --git a/src/main/haskell/Hydra/Dsl/Graph.hs b/src/main/haskell/Hydra/Dsl/Graph.hs --- a/src/main/haskell/Hydra/Dsl/Graph.hs +++ b/src/main/haskell/Hydra/Dsl/Graph.hs @@ -683,7 +683,7 @@ Core.fieldName = (Core.Name "primitives"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) -- | DSL constructor for hydra.graph.Primitive -primitive :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) -> Typed.TypedTerm Graph.Primitive +primitive :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) -> Typed.TypedTerm Graph.Primitive primitive definition implementation = Typed.TypedTerm (Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), @@ -703,7 +703,7 @@ Core.projectionFieldName = (Core.Name "definition")})), Core.applicationArgument = (Typed.unTypedTerm x)})) -- | DSL accessor for the implementation field of hydra.graph.Primitive -primitiveImplementation :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) +primitiveImplementation :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm (Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) primitiveImplementation x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermProject (Core.Projection { @@ -727,7 +727,7 @@ Core.projectionFieldName = (Core.Name "implementation")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) -- | DSL updater for the implementation field of hydra.graph.Primitive -primitiveWithImplementation :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) -> Typed.TypedTerm Graph.Primitive +primitiveWithImplementation :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm (Graph.Graph -> [Core.Term] -> Either Errors.Error Core.Term) -> Typed.TypedTerm Graph.Primitive primitiveWithImplementation original newVal = Typed.TypedTerm (Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), diff --git a/src/main/haskell/Hydra/Dsl/Libraries.hs b/src/main/haskell/Hydra/Dsl/Libraries.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Libraries.hs @@ -0,0 +1,422 @@ + +-- | Implementations of the Hydra standard libraries in Haskell +module Hydra.Dsl.Libraries ( + module Hydra.Dsl.Libraries, +) where + +import Hydra.Kernel +import Hydra.Dsl.Prims as Prims +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Types as Types + +import qualified Hydra.Haskell.Lib.Chars as Chars +import qualified Hydra.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Haskell.Lib.Equality as Equality +import qualified Hydra.Haskell.Lib.Lists as Lists +import qualified Hydra.Haskell.Lib.Literals as Literals +import qualified Hydra.Haskell.Lib.Logic as Logic +import qualified Hydra.Haskell.Lib.Maps as Maps +import qualified Hydra.Haskell.Lib.Math as Math +import qualified Hydra.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Haskell.Lib.Regex as Regex +import qualified Hydra.Haskell.Lib.Sets as Sets +import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Lib.Chars as DefChars +import qualified Hydra.Lib.Eithers as DefEithers +import qualified Hydra.Lib.Equality as DefEquality +import qualified Hydra.Lib.Lists as DefLists +import qualified Hydra.Lib.Literals as DefLiterals +import qualified Hydra.Lib.Logic as DefLogic +import qualified Hydra.Lib.Maps as DefMaps +import qualified Hydra.Lib.Math as DefMath +import qualified Hydra.Lib.Optionals as DefOptionals +import qualified Hydra.Lib.Pairs as DefPairs +import qualified Hydra.Lib.Regex as DefRegex +import qualified Hydra.Lib.Sets as DefSets +import qualified Hydra.Lib.Strings as DefStrings + +import qualified Data.List as L + + +-- Type variables (TypeVar) for primitive type schemes +-- Unconstrained +_a, _b, _c, _d, _k, _k1, _k2, _s, _v, _v1, _v2, _w, _x, _y, _z :: TypeVar +_a = v "a" +_b = v "b" +_c = v "c" +_d = v "d" +_k = v "k" +_k1 = v "k1" +_k2 = v "k2" +_s = v "s" +_v = v "v" +_v1 = v "v1" +_v2 = v "v2" +_w = v "w" +_x = v "x" +_y = v "y" +_z = v "z" + +-- Ord-constrained +_kOrd, _k1Ord, _k2Ord, _xOrd, _yOrd :: TypeVar +_kOrd = vOrd "k" +_k1Ord = vOrd "k1" +_k2Ord = vOrd "k2" +_xOrd = vOrd "x" +_yOrd = vOrd "y" + +-- Eq-constrained +_xEq :: TypeVar +_xEq = vEq "x" + +-- Term coders for type variables (used in primitive implementations) +a_, b_, c_, d_, k_, k1_, k2_, s_, v_, v1_, v2_, w_, x_, y_, z_ :: TermCoder Term +a_ = variable "a" +b_ = variable "b" +c_ = variable "c" +d_ = variable "d" +k_ = variable "k" +k1_ = variable "k1" +k2_ = variable "k2" +s_ = variable "s" +v_ = variable "v" +v1_ = variable "v1" +v2_ = variable "v2" +w_ = variable "w" +x_ = variable "x" +y_ = variable "y" +z_ = variable "z" + +-- | A TermCoder for function types which uses beta reduction to bridge term-level +-- functions to native functions. This allows higher-order primitives like map, +-- filter, foldl, etc. to use native implementations rather than eval-level ones. +-- Used by the DYNAMIC higher-order primitives (those that must inspect a reduced +-- per-element application result), pending their migration to term-level +-- defaultImplementations under issue #446. +fun :: TermCoder x -> TermCoder y -> TermCoder (x -> y) +fun = Prims.functionWithReduce (\cx g t -> reduceTerm cx g True t) + +-- | A graph-free TermCoder for function types (issue #446): the bridged native function builds an +-- unreduced @apply funTerm argTerm@ term and lets the outer reducer fold it, rather than calling +-- the reducer here. Used by the STATIC higher-order primitives — those whose result shape is fixed +-- by the (already-reduced) data argument's spine, so they never inspect a reduced per-element +-- application. This is the form that requires no InferenceContext/Graph, enabling the carrier drop. +funT :: TermCoder x -> TermCoder y -> TermCoder (x -> y) +funT = Prims.functionDeferred + +hydraLibChars :: Library +hydraLibChars = standardLibrary [ + prim1 DefChars.isAlphaNum Chars.isAlphaNum [] int32 boolean, + prim1 DefChars.isLower Chars.isLower [] int32 boolean, + prim1 DefChars.isSpace Chars.isSpace [] int32 boolean, + prim1 DefChars.isUpper Chars.isUpper [] int32 boolean, + prim1 DefChars.toLower Chars.toLower [] int32 int32, + prim1 DefChars.toUpper Chars.toUpper [] int32 int32] + +hydraLibEithers :: Library +hydraLibEithers = standardLibrary [ + prim3 DefEithers.bimap Eithers.bimap [_x, _y, _z, _w] (funT x_ z_) (funT y_ w_) (Prims.either_ x_ y_) (Prims.either_ z_ w_), + prim2 DefEithers.bind Eithers.bind [_x, _y, _z] (Prims.either_ x_ y_) (fun y_ (Prims.either_ x_ z_)) (Prims.either_ x_ z_), + prim3 DefEithers.either Eithers.either [_x, _y, _z] (funT x_ z_) (funT y_ z_) (Prims.either_ x_ y_) z_, + prim3 DefEithers.foldl Eithers.foldl [_x, _y, _z] (fun x_ (fun y_ (Prims.either_ z_ x_))) x_ (list y_) (Prims.either_ z_ x_), + Prims.lazyArgs [0] $ prim2 DefEithers.fromLeft Eithers.fromLeft [_x, _y] x_ (Prims.either_ x_ y_) x_, + Prims.lazyArgs [0] $ prim2 DefEithers.fromRight Eithers.fromRight [_x, _y] y_ (Prims.either_ x_ y_) y_, + prim1 DefEithers.isLeft Eithers.isLeft [_x, _y] (Prims.either_ x_ y_) boolean, + prim1 DefEithers.isRight Eithers.isRight [_x, _y] (Prims.either_ x_ y_) boolean, + prim1 DefEithers.lefts Eithers.lefts [_x, _y] (list $ Prims.either_ x_ y_) (list x_), + prim2 DefEithers.map Eithers.map [_x, _y, _z] (funT x_ y_) (Prims.either_ z_ x_) (Prims.either_ z_ y_), + prim2 DefEithers.mapList Eithers.mapList [_x, _y, _z] (fun x_ (Prims.either_ z_ y_)) (list x_) (Prims.either_ z_ (list y_)), + prim2 DefEithers.mapOptional Eithers.mapOptional [_x, _y, _z] (fun x_ (Prims.either_ z_ y_)) (optional x_) (Prims.either_ z_ (optional y_)), + prim2 DefEithers.mapSet Eithers.mapSet [_x, _y, _z] (fun x_ (Prims.either_ z_ y_)) (set x_) (Prims.either_ z_ (set y_)), + prim1 DefEithers.partitionEithers Eithers.partitionEithers [_x, _y] (list $ Prims.either_ x_ y_) (pair (list x_) (list y_)), + prim1 DefEithers.rights Eithers.rights [_x, _y] (list $ Prims.either_ x_ y_) (list y_)] + +hydraLibEquality :: Library +hydraLibEquality = standardLibrary [ + prim2 DefEquality.compare Equality.compare [_xOrd] x_ x_ comparison, + prim2 DefEquality.equal Equality.equal [_xEq] x_ x_ boolean, + prim2 DefEquality.gt Equality.gt [_xOrd] x_ x_ boolean, + prim2 DefEquality.gte Equality.gte [_xOrd] x_ x_ boolean, + prim1 DefEquality.identity Equality.identity [_x] x_ x_, + prim2 DefEquality.lt Equality.lt [_xOrd] x_ x_ boolean, + prim2 DefEquality.lte Equality.lte [_xOrd] x_ x_ boolean, + prim2 DefEquality.max Equality.max [_xOrd] x_ x_ x_, + prim2 DefEquality.min Equality.min [_xOrd] x_ x_ x_] + +hydraLibLists :: Library +hydraLibLists = standardLibrary [ + prim2 DefLists.apply Lists.apply [_x, _y] (list $ funT x_ y_) (list x_) (list y_), + prim2 DefLists.bind Lists.bind [_x, _y] (list x_) (fun x_ (list y_)) (list y_), + prim1 DefLists.concat Lists.concat [_x] (list (list x_)) (list x_), + prim2 DefLists.concat2 Lists.concat2 [_x] (list x_) (list x_) (list x_), + prim2 DefLists.cons Lists.cons [_x] x_ (list x_) (list x_), + prim2 DefLists.drop Lists.drop [_x] int32 (list x_) (list x_), + prim2 DefLists.dropWhile Lists.dropWhile [_x] (fun x_ boolean) (list x_) (list x_), + prim2 DefLists.elem Lists.elem [_xEq] x_ (list x_) boolean, + prim2 DefLists.filter Lists.filter [_x] (fun x_ boolean) (list x_) (list x_), + prim2 DefLists.find Lists.find [_x] (fun x_ boolean) (list x_) (optional x_), + prim3 DefLists.foldl Lists.foldl [_y, _x] (funT y_ (funT x_ y_)) y_ (list x_) y_, + prim3 DefLists.foldr Lists.foldr [_x, _y] (funT x_ (funT y_ y_)) y_ (list x_) y_, + prim1 DefLists.group Lists.group [_xEq] (list x_) (list (list x_)), + prim2 DefLists.intercalate Lists.intercalate [_x] (list x_) (list (list x_)) (list x_), + prim2 DefLists.intersperse Lists.intersperse [_x] x_ (list x_) (list x_), + prim1 DefLists.length Lists.length [_x] (list x_) int32, + prim2 DefLists.map Lists.map [_x, _y] (funT x_ y_) (list x_) (list y_), + prim2 DefLists.maybeAt Lists.maybeAt [_x] int32 (list x_) (optional x_), + prim1 DefLists.maybeHead Lists.maybeHead [_x] (list x_) (optional x_), + prim1 DefLists.maybeInit Lists.maybeInit [_x] (list x_) (optional (list x_)), + prim1 DefLists.maybeLast Lists.maybeLast [_x] (list x_) (optional x_), + prim1 DefLists.maybeTail Lists.maybeTail [_x] (list x_) (optional (list x_)), + prim1 DefLists.nub Lists.nub [_xEq] (list x_) (list x_), + prim1 DefLists.null Lists.null [_x] (list x_) boolean, + prim2 DefLists.partition Lists.partition [_x] (fun x_ boolean) (list x_) (pair (list x_) (list x_)), + prim1 DefLists.pure Lists.pure [_x] x_ (list x_), + prim2 DefLists.replicate Lists.replicate [_x] int32 x_ (list x_), + prim1 DefLists.reverse Lists.reverse [_x] (list x_) (list x_), + prim1 DefLists.singleton Lists.singleton [_x] x_ (list x_), + prim1 DefLists.sort Lists.sort [_xOrd] (list x_) (list x_), + prim2 DefLists.sortOn Lists.sortOn [_x, _yOrd] (fun x_ y_) (list x_) (list x_), + prim2 DefLists.span Lists.span [_x] (fun x_ boolean) (list x_) (pair (list x_) (list x_)), + prim2 DefLists.take Lists.take [_x] int32 (list x_) (list x_), + prim1 DefLists.transpose Lists.transpose [_x] (list (list x_)) (list (list x_)), + prim1 DefLists.uncons Lists.uncons [_x] (list x_) (optional (pair x_ (list x_))), + prim2 DefLists.zip Lists.zip [_x, _y] (list x_) (list y_) (list (pair x_ y_)), + prim3 DefLists.zipWith Lists.zipWith [_x, _y, _z] (funT x_ $ funT y_ z_) (list x_) (list y_) (list z_)] + +hydraLibLiterals :: Library +hydraLibLiterals = standardLibrary [ + prim1 DefLiterals.bigintToDecimal Literals.bigintToDecimal [] bigint decimal, + prim1 DefLiterals.bigintToInt8 Literals.bigintToInt8 [] bigint int8, + prim1 DefLiterals.bigintToInt16 Literals.bigintToInt16 [] bigint int16, + prim1 DefLiterals.bigintToInt32 Literals.bigintToInt32 [] bigint int32, + prim1 DefLiterals.bigintToInt64 Literals.bigintToInt64 [] bigint int64, + prim1 DefLiterals.bigintToUint8 Literals.bigintToUint8 [] bigint uint8, + prim1 DefLiterals.bigintToUint16 Literals.bigintToUint16 [] bigint uint16, + prim1 DefLiterals.bigintToUint32 Literals.bigintToUint32 [] bigint uint32, + prim1 DefLiterals.bigintToUint64 Literals.bigintToUint64 [] bigint uint64, + prim1 DefLiterals.binaryToBytes Literals.binaryToBytes [] binary (list int32), + prim1 DefLiterals.binaryToString Literals.binaryToString [] binary string, + prim1 DefLiterals.decimalToBigint Literals.decimalToBigint [] decimal bigint, + prim1 DefLiterals.decimalToFloat32 Literals.decimalToFloat32 [] decimal float32, + prim1 DefLiterals.decimalToFloat64 Literals.decimalToFloat64 [] decimal float64, + prim1 DefLiterals.float32ToDecimal Literals.float32ToDecimal [] float32 decimal, + prim1 DefLiterals.float32ToFloat64 Literals.float32ToFloat64 [] float32 float64, + prim1 DefLiterals.float64ToDecimal Literals.float64ToDecimal [] float64 decimal, + prim1 DefLiterals.float64ToFloat32 Literals.float64ToFloat32 [] float64 float32, + prim1 DefLiterals.int8ToBigint Literals.int8ToBigint [] int8 bigint, + prim1 DefLiterals.int16ToBigint Literals.int16ToBigint [] int16 bigint, + prim1 DefLiterals.int32ToBigint Literals.int32ToBigint [] int32 bigint, + prim1 DefLiterals.int64ToBigint Literals.int64ToBigint [] int64 bigint, + prim1 DefLiterals.readBigint Literals.readBigint [] string (optional bigint), + prim1 DefLiterals.readBoolean Literals.readBoolean [] string (optional boolean), + prim1 DefLiterals.readDecimal Literals.readDecimal [] string (optional decimal), + prim1 DefLiterals.readFloat32 Literals.readFloat32 [] string (optional float32), + prim1 DefLiterals.readFloat64 Literals.readFloat64 [] string (optional float64), + prim1 DefLiterals.readInt8 Literals.readInt8 [] string (optional int8), + prim1 DefLiterals.readInt16 Literals.readInt16 [] string (optional int16), + prim1 DefLiterals.readInt32 Literals.readInt32 [] string (optional int32), + prim1 DefLiterals.readInt64 Literals.readInt64 [] string (optional int64), + prim1 DefLiterals.readString Literals.readString [] string (optional string), + prim1 DefLiterals.readUint8 Literals.readUint8 [] string (optional uint8), + prim1 DefLiterals.readUint16 Literals.readUint16 [] string (optional uint16), + prim1 DefLiterals.readUint32 Literals.readUint32 [] string (optional uint32), + prim1 DefLiterals.readUint64 Literals.readUint64 [] string (optional uint64), + prim1 DefLiterals.showBigint Literals.showBigint [] bigint string, + prim1 DefLiterals.showBoolean Literals.showBoolean [] boolean string, + prim1 DefLiterals.showDecimal Literals.showDecimal [] decimal string, + prim1 DefLiterals.showFloat32 Literals.showFloat32 [] float32 string, + prim1 DefLiterals.showFloat64 Literals.showFloat64 [] float64 string, + prim1 DefLiterals.showInt8 Literals.showInt8 [] int8 string, + prim1 DefLiterals.showInt16 Literals.showInt16 [] int16 string, + prim1 DefLiterals.showInt32 Literals.showInt32 [] int32 string, + prim1 DefLiterals.showInt64 Literals.showInt64 [] int64 string, + prim1 DefLiterals.showString Literals.showString [] string string, + prim1 DefLiterals.showUint8 Literals.showUint8 [] uint8 string, + prim1 DefLiterals.showUint16 Literals.showUint16 [] uint16 string, + prim1 DefLiterals.showUint32 Literals.showUint32 [] uint32 string, + prim1 DefLiterals.showUint64 Literals.showUint64 [] uint64 string, + prim1 DefLiterals.stringToBinary Literals.stringToBinary [] string binary, + prim1 DefLiterals.uint8ToBigint Literals.uint8ToBigint [] uint8 bigint, + prim1 DefLiterals.uint16ToBigint Literals.uint16ToBigint [] uint16 bigint, + prim1 DefLiterals.uint32ToBigint Literals.uint32ToBigint [] uint32 bigint, + prim1 DefLiterals.uint64ToBigint Literals.uint64ToBigint [] uint64 bigint] + +hydraLibLogic :: Library +hydraLibLogic = standardLibrary [ + prim2 DefLogic.and Logic.and [] boolean boolean boolean, + Prims.lazyArgs [1, 2] $ prim3 DefLogic.ifElse Logic.ifElse [_x] boolean x_ x_ x_, + prim1 DefLogic.not Logic.not [] boolean boolean, + prim2 DefLogic.or Logic.or [] boolean boolean boolean] + +hydraLibMaps :: Library +hydraLibMaps = standardLibrary [ + prim3 DefMaps.alter Maps.alter [_v, _kOrd] (fun (optional v_) (optional v_)) k_ mapKv mapKv, + prim3 DefMaps.bimap Maps.bimap [_k1Ord, _k2Ord, _v1, _v2] (fun k1_ k2_) (fun v1_ v2_) (Prims.map k1_ v1_) (Prims.map k2_ v2_), + prim2 DefMaps.delete Maps.delete [_kOrd, _v] k_ mapKv mapKv, + prim1 DefMaps.elems Maps.elems [_kOrd, _v] mapKv (list v_), + prim0 DefMaps.empty Maps.empty [_kOrd, _v] mapKv, + prim2 DefMaps.filter Maps.filter [_v, _kOrd] (fun v_ boolean) mapKv mapKv, + prim2 DefMaps.filterWithKey Maps.filterWithKey [_kOrd, _v] (fun k_ (fun v_ boolean)) mapKv mapKv, + Prims.lazyArgs [0] $ prim3 DefMaps.findWithDefault Maps.findWithDefault [_v, _kOrd] v_ k_ mapKv v_, + prim1 DefMaps.fromList Maps.fromList [_kOrd, _v] (list $ pair k_ v_) mapKv, + prim3 DefMaps.insert Maps.insert [_kOrd, _v] k_ v_ mapKv mapKv, + prim1 DefMaps.keys Maps.keys [_kOrd, _v] mapKv (list k_), + prim2 DefMaps.lookup Maps.lookup [_kOrd, _v] k_ mapKv (optional v_), + prim2 DefMaps.map Maps.map [_v1, _v2, _kOrd] (funT v1_ v2_) (Prims.map k_ v1_) (Prims.map k_ v2_), + prim2 DefMaps.mapKeys Maps.mapKeys [_k1Ord, _k2Ord, _v] (fun k1_ k2_) (Prims.map k1_ v_) (Prims.map k2_ v_), + prim2 DefMaps.member Maps.member [_kOrd, _v] k_ mapKv boolean, + prim1 DefMaps.null Maps.null [_kOrd, _v] mapKv boolean, + prim2 DefMaps.singleton Maps.singleton [_kOrd, _v] k_ v_ mapKv, + prim1 DefMaps.size Maps.size [_kOrd, _v] mapKv int32, + prim1 DefMaps.toList Maps.toList [_kOrd, _v] mapKv (list $ pair k_ v_), + prim2 DefMaps.union Maps.union [_kOrd, _v] mapKv mapKv mapKv] + where + mapKv = Prims.map k_ v_ + +hydraLibMathFloat64 :: Library +hydraLibMathFloat64 = standardLibrary [ + prim1 DefMath.acos Math.acos [] float64 float64, + prim1 DefMath.acosh Math.acosh [] float64 float64, + prim2 DefMath.addFloat64 Math.addFloat64 [] float64 float64 float64, + prim1 DefMath.asin Math.asin [] float64 float64, + prim1 DefMath.asinh Math.asinh [] float64 float64, + prim1 DefMath.atan Math.atan [] float64 float64, + prim2 DefMath.atan2 Math.atan2 [] float64 float64 float64, + prim1 DefMath.atanh Math.atanh [] float64 float64, + prim1 DefMath.ceiling Math.ceiling [] float64 float64, + prim1 DefMath.cos Math.cos [] float64 float64, + prim1 DefMath.cosh Math.cosh [] float64 float64, + prim0 DefMath.e Math.e [] float64, + prim1 DefMath.exp Math.exp [] float64 float64, + prim1 DefMath.floor Math.floor [] float64 float64, + prim1 DefMath.log Math.log [] float64 float64, + prim2 DefMath.logBase Math.logBase [] float64 float64 float64, + prim2 DefMath.mulFloat64 Math.mulFloat64 [] float64 float64 float64, + prim1 DefMath.negateFloat64 Math.negateFloat64 [] float64 float64, + prim0 DefMath.pi Math.pi [] float64, + prim2 DefMath.pow Math.pow [] float64 float64 float64, + prim1 DefMath.round Math.round [] float64 float64, + prim2 DefMath.roundFloat32 Math.roundFloat32 [] int32 float32 float32, + prim2 DefMath.roundFloat64 Math.roundFloat64 [] int32 float64 float64, + prim1 DefMath.sin Math.sin [] float64 float64, + prim1 DefMath.sinh Math.sinh [] float64 float64, + prim1 DefMath.sqrt Math.sqrt [] float64 float64, + prim2 DefMath.subFloat64 Math.subFloat64 [] float64 float64 float64, + prim1 DefMath.tan Math.tan [] float64 float64, + prim1 DefMath.tanh Math.tanh [] float64 float64, + prim1 DefMath.truncate Math.truncate [] float64 float64] + +hydraLibMathInt32 :: Library +hydraLibMathInt32 = standardLibrary [ + prim1 DefMath.abs Math.abs [] int32 int32, + prim2 DefMath.add Math.add [] int32 int32 int32, + prim1 DefMath.even Math.even [] int32 boolean, + prim2 DefMath.max Math.max [] int32 int32 int32, + prim2 DefMath.maybeDiv Math.maybeDiv [] int32 int32 (optional int32), + prim2 DefMath.min Math.min [] int32 int32 int32, + prim2 DefMath.maybeMod Math.maybeMod [] int32 int32 (optional int32), + prim2 DefMath.mul Math.mul [] int32 int32 int32, + prim1 DefMath.negate Math.negate [] int32 int32, + prim1 DefMath.odd Math.odd [] int32 boolean, + prim1 DefMath.maybePred Math.maybePred [] int32 (optional int32), + prim2 DefMath.range Math.range [] int32 int32 (list int32), + prim2 DefMath.maybeRem Math.maybeRem [] int32 int32 (optional int32), + prim1 DefMath.signum Math.signum [] int32 int32, + prim2 DefMath.sub Math.sub [] int32 int32 int32, + prim1 DefMath.maybeSucc Math.maybeSucc [] int32 (optional int32)] + +hydraLibOptionals :: Library +hydraLibOptionals = standardLibrary [ + prim2 DefOptionals.apply Optionals.apply [_x, _y] (optional $ funT x_ y_) (optional x_) (optional y_), + prim2 DefOptionals.bind Optionals.bind [_x, _y] (optional x_) (fun x_ (optional y_)) (optional y_), + Prims.lazyArgs [1] $ prim3 DefOptionals.cases Optionals.cases [_x, _y] (optional x_) y_ (funT x_ y_) y_, + prim1 DefOptionals.cat Optionals.cat [_x] (list $ optional x_) (list x_), + prim3 DefOptionals.compose Optionals.compose [_x, _y, _z] (fun x_ $ optional y_) (fun y_ $ optional z_) x_ (optional z_), + Prims.lazyArgs [0] $ prim2 DefOptionals.fromOptional Optionals.fromOptional [_x] x_ (optional x_) x_, + prim1 DefOptionals.isGiven Optionals.isGiven [_x] (optional x_) boolean, + prim1 DefOptionals.isNone Optionals.isNone [_x] (optional x_) boolean, + prim2 DefOptionals.map Optionals.map [_x, _y] (funT x_ y_) (optional x_) (optional y_), + prim2 DefOptionals.mapOptional Optionals.mapOptional [_x, _y] (fun x_ $ optional y_) (list x_) (list y_), + prim1 DefOptionals.pure Optionals.pure [_x] x_ (optional x_), + prim1 DefOptionals.toList Optionals.toList [_x] (optional x_) (list x_)] + +hydraLibPairs :: Library +hydraLibPairs = standardLibrary [ + prim3 DefPairs.bimap Pairs.bimap [_a, _b, _c, _d] (funT a_ c_) (funT b_ d_) (pair a_ b_) (pair c_ d_), + prim1 DefPairs.first Pairs.first [_a, _b] (pair a_ b_) a_, + prim1 DefPairs.second Pairs.second [_a, _b] (pair a_ b_) b_] + +hydraLibRegex :: Library +hydraLibRegex = standardLibrary [ + prim2 DefRegex.find Regex.find [] string string (optional string), + prim2 DefRegex.findAll Regex.findAll [] string string (list string), + prim2 DefRegex.matches Regex.matches [] string string boolean, + prim3 DefRegex.replace Regex.replace [] string string string string, + prim3 DefRegex.replaceAll Regex.replaceAll [] string string string string, + prim2 DefRegex.split Regex.split [] string string (list string)] + +hydraLibSets :: Library +hydraLibSets = standardLibrary [ + prim2 DefSets.delete Sets.delete [_xOrd] x_ (set x_) (set x_), + prim2 DefSets.difference Sets.difference [_xOrd] (set x_) (set x_) (set x_), + prim0 DefSets.empty Sets.empty [_xOrd] (set x_), + prim1 DefSets.fromList Sets.fromList [_xOrd] (list x_) (set x_), + prim2 DefSets.insert Sets.insert [_xOrd] x_ (set x_) (set x_), + prim2 DefSets.intersection Sets.intersection [_xOrd] (set x_) (set x_) (set x_), + prim2 DefSets.map Sets.map [_xOrd, _yOrd] (fun x_ y_) (set x_) (set y_), + prim2 DefSets.member Sets.member [_xOrd] x_ (set x_) boolean, + prim1 DefSets.null Sets.null [_xOrd] (set x_) boolean, + prim1 DefSets.singleton Sets.singleton [_xOrd] x_ (set x_), + prim1 DefSets.size Sets.size [_xOrd] (set x_) int32, + prim1 DefSets.toList Sets.toList [_xOrd] (set x_) (list x_), + prim2 DefSets.union Sets.union [_xOrd] (set x_) (set x_) (set x_), + prim1 DefSets.unions Sets.unions [_xOrd] (list $ set x_) (set x_)] + +hydraLibStrings :: Library +hydraLibStrings = standardLibrary [ + prim1 DefStrings.cat Strings.cat [] (list string) string, + prim2 DefStrings.cat2 Strings.cat2 [] string string string, + prim1 DefStrings.fromList Strings.fromList [] (list int32) string, + prim2 DefStrings.intercalate Strings.intercalate [] string (list string) string, + prim1 DefStrings.length Strings.length [] string int32, + prim1 DefStrings.lines Strings.lines [] string (list string), + prim2 DefStrings.maybeCharAt Strings.maybeCharAt [] int32 string (optional int32), + prim1 DefStrings.null Strings.null [] string boolean, + prim2 DefStrings.splitOn Strings.splitOn [] string string (list string), + prim1 DefStrings.toList Strings.toList [] string (list int32), + prim1 DefStrings.toLower Strings.toLower [] string string, + prim1 DefStrings.toUpper Strings.toUpper [] string string, + prim1 DefStrings.unlines Strings.unlines [] (list string) string] + +standardLibraries :: [Library] +standardLibraries = [ + hydraLibChars, + hydraLibEithers, + hydraLibEquality, + hydraLibLists, + hydraLibLiterals, + hydraLibLogic, + hydraLibMaps, + hydraLibMathFloat64, + hydraLibMathInt32, + hydraLibOptionals, + hydraLibPairs, + hydraLibRegex, + hydraLibSets, + hydraLibStrings] + +-- | Assemble a library from its primitives. The library's module name (e.g. "hydra.lib.chars") +-- is *derived* from the primitives' shared namespace rather than passed as a literal string (#473): +-- every primitive in a library shares the namespace, so it is read off the first one's +-- PrimitiveDefinition name. Fails loudly on an empty list. +standardLibrary :: [Primitive] -> Library +standardLibrary [] = error "standardLibrary: empty primitive list (cannot derive module name)" +standardLibrary prims = Library { + libraryName = ns, + libraryPrefix = L.drop (L.length ("hydra.lib." :: String)) $ unModuleName ns, + libraryPrimitives = prims} + where + -- namespace = the primitive name with its final "." segment dropped + firstName = unName $ primitiveDefinitionName $ primitiveDefinition $ head prims + ns = ModuleName $ reverse $ L.drop 1 $ L.dropWhile (/= '.') $ reverse firstName diff --git a/src/main/haskell/Hydra/Dsl/LiteralTypes.hs b/src/main/haskell/Hydra/Dsl/LiteralTypes.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/LiteralTypes.hs @@ -0,0 +1,86 @@ +-- | A DSL for Hydra literal types in Haskell + +module Hydra.Dsl.LiteralTypes where + +import Hydra.Core + + +-- | Arbitrary-precision integer type +-- Example: bigint +bigint :: LiteralType +bigint = LiteralTypeInteger IntegerTypeBigint + +-- | Binary data type +-- Example: binary +binary :: LiteralType +binary = LiteralTypeBinary + +-- | Boolean type +-- Example: boolean +boolean :: LiteralType +boolean = LiteralTypeBoolean + +-- | Create a floating point type with the specified precision +-- Example: float FloatTypeFloat32 +float :: FloatType -> LiteralType +float = LiteralTypeFloat + +-- | 32-bit floating point type +-- Example: float32 +float32 :: LiteralType +float32 = float FloatTypeFloat32 + +-- | 64-bit floating point type +-- Example: float64 +float64 :: LiteralType +float64 = float FloatTypeFloat64 + +-- | 16-bit signed integer type +-- Example: int16 +int16 :: LiteralType +int16 = integer IntegerTypeInt16 + +-- | 32-bit signed integer type +-- Example: int32 +int32 :: LiteralType +int32 = integer IntegerTypeInt32 + +-- | 64-bit signed integer type +-- Example: int64 +int64 :: LiteralType +int64 = integer IntegerTypeInt64 + +-- | 8-bit signed integer type +-- Example: int8 +int8 :: LiteralType +int8 = integer IntegerTypeInt8 + +-- | Create an integer type with the specified bit width +-- Example: integer IntegerTypeInt32 +integer :: IntegerType -> LiteralType +integer = LiteralTypeInteger + +-- | String type +-- Example: string +string :: LiteralType +string = LiteralTypeString + +-- | 16-bit unsigned integer type +-- Example: uint16 +uint16 :: LiteralType +uint16 = integer IntegerTypeUint16 + +-- | 32-bit unsigned integer type +-- Example: uint32 +uint32 :: LiteralType +uint32 = integer IntegerTypeUint32 + +-- | 64-bit unsigned integer type +-- Example: uint64 +uint64 :: LiteralType +uint64 = integer IntegerTypeUint64 + +-- | 8-bit unsigned integer type +-- Example: uint8 +uint8 :: LiteralType +uint8 = integer IntegerTypeUint8 diff --git a/src/main/haskell/Hydra/Dsl/Meta/Base.hs b/src/main/haskell/Hydra/Dsl/Meta/Base.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Base.hs @@ -0,0 +1,28 @@ +-- | A basis for other DSLs which deal with term-encoded expressions. + +module Hydra.Dsl.Meta.Base ( + module Hydra.Dsl.Meta.Phantoms, + module Hydra.Dsl.Meta.Base, + module Hydra.Dsl.Libraries, +) where + +import Hydra.Kernel +import Hydra.Dsl.Meta.Phantoms(asTerm, AsTerm(..), definitionInModule, el, firstClassType, opt) +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Meta.Core as Core +import Hydra.Dsl.Libraries + +import qualified Data.Map as M +import qualified Data.Maybe as Y + + +infixr 0 >: +(>:) :: String -> a -> (TypedTerm Name, a) +n >: d = (name n, d) + +infixr 0 >>: +(>>:) :: Name -> a -> (TypedTerm Name, a) +n >>: d = (Core.nameLift n, d) + +name :: String -> TypedTerm Name +name s = Core.nameLift $ Name s diff --git a/src/main/haskell/Hydra/Dsl/Meta/Core.hs b/src/main/haskell/Hydra/Dsl/Meta/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Core.hs @@ -0,0 +1,56 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Haskell-specific convenience layer over the generated Hydra.Dsl.Core module. +-- Re-exports all generated DSL functions and adds AsTerm-flexible overrides +-- for functions commonly called with TypedBinding arguments. + +module Hydra.Dsl.Meta.Core ( + module Hydra.Dsl.Core, + module Hydra.Dsl.Meta.Core, + nameLift, +) where + +import Hydra.Kernel +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms (nameLift, var, (~>)) +import Hydra.Dsl.Core hiding (binding, injection, typeVariable) +import qualified Hydra.Dsl.Core as Gen + +-- For helpers +import qualified Hydra.Dsl.Meta.Lib.Equality as Equality +import qualified Hydra.Dsl.Meta.Lib.Lists as Lists +import qualified Hydra.Dsl.Meta.Lib.Logic as Logic + +import qualified Data.Map as M +import Prelude hiding (map, product) + + +-- | AsTerm-flexible overrides of generated functions. +-- These allow passing TypedBinding values where TypedTerm is expected. + +binding :: AsTerm t Term => TypedTerm Name -> t -> TypedTerm (Maybe TypeScheme) -> TypedTerm Binding +binding n t ts = Gen.binding n (asTerm t) ts + +equalNameList_ :: TypedTerm [Name] -> TypedTerm [Name] -> TypedTerm Bool +equalNameList_ lefts rights = Logic.and + (Equality.equal (Lists.length lefts) (Lists.length rights)) + (Logic.ands $ Lists.zipWith equalName lefts rights) + where + equalName = "left" ~> "right" ~> Equality.equal + (Gen.unName (var "left" :: TypedTerm Name)) + (Gen.unName (var "right" :: TypedTerm Name)) + +equalName_ :: TypedTerm Name -> TypedTerm Name -> TypedTerm Bool +equalName_ left right = Equality.equal (Gen.unName left) (Gen.unName right) + +false :: TypedTerm Term +false = termLiteral $ literalBoolean $ TypedTerm $ TermLiteral $ LiteralBoolean False + +injection :: AsTerm t Name => t -> TypedTerm Field -> TypedTerm Injection +injection n f = Gen.injection (asTerm n) f + +typeVariable :: AsTerm t Name => t -> TypedTerm Type +typeVariable n = Gen.typeVariable (asTerm n) + + +-- | Non-standard helpers (used in kernel source modules) diff --git a/src/main/haskell/Hydra/Dsl/Meta/DeepCore.hs b/src/main/haskell/Hydra/Dsl/Meta/DeepCore.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/DeepCore.hs @@ -0,0 +1,172 @@ +-- | A domain-specific language for constructing Hydra terms in Haskell. +-- +-- This DSL provides helpers for constructing "deep" terms - i.e., terms that +-- represent Hydra terms as data (Term values), as opposed to the shallow DSL +-- that works at the Haskell level. +module Hydra.Dsl.Meta.DeepCore where + +import Hydra.Kernel +import Hydra.Dsl.Terms (ToPrimName(..)) +import qualified Hydra.Dsl.Meta.Core as Core +import qualified Hydra.Dsl.Meta.Phantoms as P + +import qualified Data.Char as C +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Set as S + + +-------------------------------------------------------------------------------- +-- Application operators +-------------------------------------------------------------------------------- + +-- | Apply a function term to an argument term (infix operator, alias) +(@@@) :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +fun @@@ arg = apply fun arg + +-- | Apply a function term to an argument term +apply :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +apply lhs rhs = Core.termApplication $ Core.application lhs rhs + +-------------------------------------------------------------------------------- +-- Case statements and pattern matching +-------------------------------------------------------------------------------- + +cases :: Name -> TypedTerm Term -> TypedTerm (Maybe Term) -> [TypedTerm CaseAlternative] -> TypedTerm Term +cases tname arg dflt alts = match tname dflt alts @@@ arg + +-- | Create a field (e.g. for injection payloads) +field :: Name -> TypedTerm Term -> TypedTerm Field +field fname body = Core.field (Core.nameLift fname) body + +-- | Create a case alternative (a variant tag together with its handler) for case matching +caseAlternative :: Name -> TypedTerm Term -> TypedTerm CaseAlternative +caseAlternative aname handler = Core.caseAlternative (Core.nameLift aname) handler + +-- | Create a union case statement with optional default case +match :: Name -> TypedTerm (Maybe Term) -> [TypedTerm CaseAlternative] -> TypedTerm Term +match tname dflt alts = Core.termCases $ + Core.caseStatement + (Core.nameLift tname) + dflt + (P.list alts) + +-------------------------------------------------------------------------------- +-- Functions and lambdas +-------------------------------------------------------------------------------- + +constant :: TypedTerm Term -> TypedTerm Term +constant = lambda ignoredVariable + +-- | Create a lambda term with a variable name and body +lambda :: String -> TypedTerm Term -> TypedTerm Term +lambda v body = Core.termLambda $ Core.lambda (Core.name (P.string v)) P.nothing $ body + +-- | Create a lambda term with a dynamic parameter name, optional domain, and body +lambdaTyped :: TypedTerm Name -> TypedTerm (Maybe Type) -> TypedTerm Term -> TypedTerm Term +lambdaTyped name domain body = Core.termLambda $ Core.lambda name domain body + +-- | Create a reference to a primitive function. +-- Uses termVariable; the name resolves via graphPrimitives fallthrough. +primitive :: ToPrimName n => n -> TypedTerm Term +primitive = Core.termVariable . Core.nameLift . toPrimName + +-- TODO: this is probably equivalent to `primitive`. +-- | Create a reference to a primitive function using encodedName +-- (for primitives that need namespace encoding) +primitiveEncoded :: ToPrimName n => n -> TypedTerm Term +primitiveEncoded = Core.termVariable . P.encodedName . toPrimName + +-------------------------------------------------------------------------------- +-- Projections and eliminations +-------------------------------------------------------------------------------- + +-- | Create a record field projection +project :: Name -> Name -> TypedTerm Term +project tname fname = Core.termProject $ + Core.projection (Core.nameLift tname) (Core.nameLift fname) + +unwrap :: Name -> TypedTerm Term +unwrap name = unwrapDynamic (Core.nameLift name) + +-- | Create an unwrap elimination for a wrapped type +unwrapDynamic :: TypedTerm Name -> TypedTerm Term +unwrapDynamic tname = Core.termUnwrap tname + +-------------------------------------------------------------------------------- +-- Literals and basic terms +-------------------------------------------------------------------------------- + +-- | Create a string literal term +string :: TypedTerm String -> TypedTerm Term +string s = Core.termLiteral $ Core.literalString s + +-- | Create a unit term +unit :: TypedTerm Term +unit = Core.termUnit + +-- | Create a variable reference term +var :: String -> TypedTerm Term +var s = Core.termVariable $ Core.name $ P.string s + +-------------------------------------------------------------------------------- +-- Compound terms (records, unions, wraps, lists) +-------------------------------------------------------------------------------- + +-- | Create an Either term (left or right) +either :: TypedTerm (Either Term Term) -> TypedTerm Term +either e = Core.termEither e + +-- | Create a union injection term +injection :: Name -> TypedTerm Field -> TypedTerm Term +injection tname fld = Core.termInject $ Core.injection (Core.nameLift tname) fld + +-- | Create a Just term +just :: TypedTerm Term -> TypedTerm Term +just (TypedTerm t) = TypedTerm $ TermOptional $ Just t + +left :: TypedTerm Term -> TypedTerm Term +left (TypedTerm t) = Core.termEither $ TypedTerm $ TermEither $ Left t + +-- | Create a single let binding +letn :: String -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term +letn name value body = lets [(name, value)] body + +-- | Create a let expression with bindings and a body +-- Each binding is a (name, term) pair +lets :: [(String, TypedTerm Term)] -> TypedTerm Term -> TypedTerm Term +lets bindings body = Core.termLet $ Core.let_ + (P.list [Core.binding (Core.name (P.string n)) t P.nothing | (n, t) <- bindings]) + body + +-- | Create a list term from a list of terms +list :: TypedTerm [Term] -> TypedTerm Term +list terms = Core.termList terms + +map :: TypedTerm (M.Map Term Term) -> TypedTerm Term +map terms = Core.termMap terms + +-- | Create a Nothing term +nothing :: TypedTerm Term +nothing = TypedTerm $ TermOptional Nothing + +pair :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +pair (TypedTerm first) (TypedTerm second) = Core.termPair $ TypedTerm $ TermPair (first, second) + +-- | Create a record term with a type name and fields +record :: Name -> [TypedTerm Field] -> TypedTerm Term +record tname fields = Core.termRecord $ Core.record (Core.nameLift tname) (P.list fields) + +ref :: TypedTermDefinition a -> TypedTerm Term +ref (TypedTermDefinition name _) = Core.termVariable $ Core.nameLift name + +right :: TypedTerm Term -> TypedTerm Term +right (TypedTerm t) = Core.termEither $ TypedTerm $ TermEither $ Right t + +-- | Create a wrap term with a type name and body +wrap :: Name -> TypedTerm Term -> TypedTerm Term +wrap tname body = Core.termWrap $ Core.wrappedTerm (Core.nameLift tname) body + +-- | Create a wrap term with a dynamic type name (TypedTerm Name) +wrapDynamic :: TypedTerm Name -> TypedTerm Term -> TypedTerm Term +wrapDynamic tname body = Core.termWrap $ Core.wrappedTerm tname body diff --git a/src/main/haskell/Hydra/Dsl/Meta/Graph.hs b/src/main/haskell/Hydra/Dsl/Meta/Graph.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Graph.hs @@ -0,0 +1,38 @@ +-- | Haskell-specific convenience layer over the generated Hydra.Dsl.Graph module. +-- Re-exports all generated DSL functions and adds non-standard helpers. + +module Hydra.Dsl.Meta.Graph ( + module Hydra.Dsl.Graph, + module Hydra.Dsl.Meta.Graph, +) where + +import Hydra.Kernel +import Hydra.Dsl.Meta.Phantoms +import Hydra.Dsl.Graph + +import qualified Hydra.Dsl.Meta.Lib.Maps as Maps +import qualified Hydra.Dsl.Meta.Lib.Sets as Sets + + +-- | Non-standard helpers + +comparisonEqualTo :: TypedTerm Comparison +comparisonEqualTo = injectUnit _Comparison _Comparison_equalTo + +comparisonGreaterThan :: TypedTerm Comparison +comparisonGreaterThan = injectUnit _Comparison _Comparison_greaterThan + +comparisonLessThan :: TypedTerm Comparison +comparisonLessThan = injectUnit _Comparison _Comparison_lessThan + +emptyGraph :: TypedTerm Graph +emptyGraph = graph + Maps.empty -- boundTerms + Maps.empty -- boundTypes + Maps.empty -- classConstraints + Sets.empty -- lambdaVariables + Maps.empty -- metadata + Maps.empty -- primitives + Maps.empty -- schemaTypes + Sets.empty -- typeVariables + diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Chars.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Chars.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Chars.hs @@ -0,0 +1,34 @@ +-- | Phantom-typed term DSL for the hydra.lib.chars library + +module Hydra.Dsl.Meta.Lib.Chars where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Chars as DefChars + + +-- | Check whether a character is alphanumeric. +isAlphaNum :: TypedTerm Int -> TypedTerm Bool +isAlphaNum = primitive1 DefChars.isAlphaNum + +-- | Check whether a character is lowercase. +isLower :: TypedTerm Int -> TypedTerm Bool +isLower = primitive1 DefChars.isLower + +-- | Check whether a character is a whitespace character. +isSpace :: TypedTerm Int -> TypedTerm Bool +isSpace = primitive1 DefChars.isSpace + +-- | Check whether a character is uppercase. +isUpper :: TypedTerm Int -> TypedTerm Bool +isUpper = primitive1 DefChars.isUpper + +-- | Convert a character to lowercase. +toLower :: TypedTerm Int -> TypedTerm Int +toLower = primitive1 DefChars.toLower + +-- | Convert a character to uppercase. +toUpper :: TypedTerm Int -> TypedTerm Int +toUpper = primitive1 DefChars.toUpper diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Eithers.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Eithers.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Eithers.hs @@ -0,0 +1,71 @@ +-- | Phantom-typed term DSL for the hydra.lib.eithers library + +module Hydra.Dsl.Meta.Lib.Eithers where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Data.Set as S +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Eithers as DefEithers + + +-- | Map over both sides of an Either value. +bimap :: TypedTerm (a -> c) -> TypedTerm (b -> d) -> TypedTerm (Either a b) -> TypedTerm (Either c d) +bimap = primitive3 DefEithers.bimap + +-- | Bind (flatMap) for Either: if Right, apply the function; if Left, return unchanged. +bind :: TypedTerm (Either a b) -> TypedTerm (b -> Either a c) -> TypedTerm (Either a c) +bind = primitive2 DefEithers.bind + +-- | Eliminate an Either value by applying one of two functions. +either_ :: TypedTerm (a -> c) -> TypedTerm (b -> c) -> TypedTerm (Either a b) -> TypedTerm c +either_ = primitive3 DefEithers.either + +-- | Left-fold over a list with an Either-returning function, short-circuiting on Left. +foldl :: TypedTerm (a -> b -> Either c a) -> TypedTerm a -> TypedTerm [b] -> TypedTerm (Either c a) +foldl = primitive3 DefEithers.foldl + +-- | Extract the Left value, or return a default. +fromLeft :: TypedTerm a -> TypedTerm (Either a b) -> TypedTerm a +fromLeft = primitive2 DefEithers.fromLeft + +-- | Extract the Right value, or return a default. +fromRight :: TypedTerm b -> TypedTerm (Either a b) -> TypedTerm b +fromRight = primitive2 DefEithers.fromRight + +-- | Check if an Either is a Left value. +isLeft :: TypedTerm (Either a b) -> TypedTerm Bool +isLeft = primitive1 DefEithers.isLeft + +-- | Check if an Either is a Right value. +isRight :: TypedTerm (Either a b) -> TypedTerm Bool +isRight = primitive1 DefEithers.isRight + +-- | Extract all Left values from a list of Eithers. +lefts :: TypedTerm [Either a b] -> TypedTerm [a] +lefts = primitive1 DefEithers.lefts + +-- | Map a function over the Right side of an Either (standard functor map). +map :: TypedTerm (a -> b) -> TypedTerm (Either c a) -> TypedTerm (Either c b) +map = primitive2 DefEithers.map + +-- | Map a function returning Either over a list, collecting results or short-circuiting on Left. +mapList :: TypedTerm (a -> Either e b) -> TypedTerm [a] -> TypedTerm (Either e [b]) +mapList = primitive2 DefEithers.mapList + +-- | Map a function returning Either over an optional, or return Right Nothing if Nothing. +mapOptional :: TypedTerm (a -> Either c b) -> TypedTerm (Maybe a) -> TypedTerm (Either c (Maybe b)) +mapOptional = primitive2 DefEithers.mapOptional + +-- | Map a function returning Either over a Set, collecting results or short-circuiting on Left. +mapSet :: TypedTerm (a -> Either c b) -> TypedTerm (S.Set a) -> TypedTerm (Either c (S.Set b)) +mapSet = primitive2 DefEithers.mapSet + +-- | Partition a list of Eithers into lefts and rights. +partitionEithers :: TypedTerm [Either a b] -> TypedTerm ([a], [b]) +partitionEithers = primitive1 DefEithers.partitionEithers + +-- | Extract all Right values from a list of Eithers. +rights :: TypedTerm [Either a b] -> TypedTerm [b] +rights = primitive1 DefEithers.rights diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Equality.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Equality.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Equality.hs @@ -0,0 +1,52 @@ +-- | Phantom-typed term DSL for the hydra.lib.equality library + +{-# LANGUAGE FlexibleContexts #-} + +module Hydra.Dsl.Meta.Lib.Equality where + +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import Hydra.Typed +import Hydra.Util +import qualified Hydra.Dsl.Terms as Terms + +import Data.Int +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Equality as DefEquality + + +-- | Compare two values and return a Comparison. +compare :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Comparison +compare t1 t2 = primitive2 DefEquality.compare t1 (asTerm t2) + +-- | Check if two values are equal. +equal :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Bool +equal t1 t2 = primitive2 DefEquality.equal t1 (asTerm t2) + +-- | Check if first value is greater than second. +gt :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Bool +gt t1 t2 = primitive2 DefEquality.gt t1 (asTerm t2) + +-- | Check if first value is greater than or equal to second. +gte :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Bool +gte t1 t2 = primitive2 DefEquality.gte t1 (asTerm t2) + +-- | Return a value unchanged. +identity :: TypedTerm a -> TypedTerm a +identity = primitive1 DefEquality.identity + +-- | Check if first value is less than second. +lt :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Bool +lt t1 t2 = primitive2 DefEquality.lt t1 (asTerm t2) + +-- | Check if first value is less than or equal to second. +lte :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm Bool +lte t1 t2 = primitive2 DefEquality.lte t1 (asTerm t2) + +-- | Return the maximum of two values. +max :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm a +max t1 t2 = primitive2 DefEquality.max t1 (asTerm t2) + +-- | Return the minimum of two values. +min :: AsTerm t2 a => TypedTerm a -> t2 -> TypedTerm a +min t1 t2 = primitive2 DefEquality.min t1 (asTerm t2) diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Lists.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Lists.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Lists.hs @@ -0,0 +1,161 @@ +-- | Phantom-typed term DSL for the hydra.lib.lists library + +{-# LANGUAGE FlexibleContexts #-} + +module Hydra.Dsl.Meta.Lib.Lists where + +import Hydra.Typed +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Lists as DefLists + + +-- | Apply a list of functions to a list of values (applicative style). +apply :: TypedTerm [a -> b] -> TypedTerm [a] -> TypedTerm [b] +apply = primitive2 DefLists.apply + +-- | Apply a function that returns lists to each element and flatten results. +bind :: TypedTerm [a] -> TypedTerm (a -> [b]) -> TypedTerm [b] +bind = primitive2 DefLists.bind + +-- | Concatenate a list of lists. +concat :: TypedTerm [[a]] -> TypedTerm [a] +concat = primitive1 DefLists.concat + +-- | Concatenate two lists. +concat2 :: TypedTerm [a] -> TypedTerm [a] -> TypedTerm [a] +concat2 = primitive2 DefLists.concat2 + +-- | Prepend a value to a list. +cons :: TypedTerm a -> TypedTerm [a] -> TypedTerm [a] +cons = primitive2 DefLists.cons + +-- | Drop the first n elements from a list. +drop :: TypedTerm Int -> TypedTerm [a] -> TypedTerm [a] +drop = primitive2 DefLists.drop + +-- | Drop elements from the beginning of a list while predicate is true. +dropWhile :: TypedTerm (a -> Bool) -> TypedTerm [a] -> TypedTerm [a] +dropWhile = primitive2 DefLists.dropWhile + +-- | Check if an element is in a list. +elem :: Eq a => TypedTerm a -> TypedTerm [a] -> TypedTerm Bool +elem = primitive2 DefLists.elem + +-- | Filter a list based on a predicate. +filter :: AsTerm t [a] => TypedTerm (a -> Bool) -> t -> TypedTerm [a] +filter p xs = primitive2 DefLists.filter p (asTerm xs) + +-- | Find the first element matching a predicate. +find :: TypedTerm (a -> Bool) -> TypedTerm [a] -> TypedTerm (Maybe a) +find = primitive2 DefLists.find + +-- | Fold a list from the left. +foldl :: AsTerm f (b -> a -> b) => f -> TypedTerm b -> TypedTerm [a] -> TypedTerm b +foldl f = primitive3 DefLists.foldl (asTerm f) + +-- | Fold a list from the right. +foldr :: AsTerm f (a -> b -> b) => f -> TypedTerm b -> TypedTerm [a] -> TypedTerm b +foldr f = primitive3 DefLists.foldr (asTerm f) + +-- | Group consecutive equal elements. +group :: Eq a => TypedTerm [a] -> TypedTerm [[a]] +group = primitive1 DefLists.group + +-- | Intercalate a list of lists with a separator list between each. +intercalate :: TypedTerm [a] -> TypedTerm [[a]] -> TypedTerm [a] +intercalate = primitive2 DefLists.intercalate + +-- | Intersperse a value between elements of a list. +intersperse :: TypedTerm a -> TypedTerm [a] -> TypedTerm [a] +intersperse = primitive2 DefLists.intersperse + +-- | Get the length of a list. +length :: TypedTerm [a] -> TypedTerm Int +length = primitive1 DefLists.length + +-- | Map a function over a list. +map :: (AsTerm f (a -> b), AsTerm t [a]) => f -> t -> TypedTerm [b] +map f l = primitive2 DefLists.map (asTerm f) (asTerm l) + +-- | Get the element at a specified index in a list, returning Nothing if out of bounds. +maybeAt :: TypedTerm Int -> TypedTerm [a] -> TypedTerm (Maybe a) +maybeAt = primitive2 DefLists.maybeAt + +-- | Get the first element of a list, returning Nothing if the list is empty. +maybeHead :: TypedTerm [a] -> TypedTerm (Maybe a) +maybeHead = primitive1 DefLists.maybeHead + +-- | Return all elements except the last one, returning Nothing if the list is empty. +maybeInit :: TypedTerm [a] -> TypedTerm (Maybe [a]) +maybeInit = primitive1 DefLists.maybeInit + +-- | Get the last element of a list, returning Nothing if the list is empty. +maybeLast :: TypedTerm [a] -> TypedTerm (Maybe a) +maybeLast = primitive1 DefLists.maybeLast + +-- | Get all elements of a list except the first, returning Nothing if the list is empty. +maybeTail :: TypedTerm [a] -> TypedTerm (Maybe [a]) +maybeTail = primitive1 DefLists.maybeTail + +-- | Remove duplicate elements from a list. +nub :: Eq a => TypedTerm [a] -> TypedTerm [a] +nub = primitive1 DefLists.nub + +-- | Check if a list is empty. +null :: TypedTerm [a] -> TypedTerm Bool +null = primitive1 DefLists.null + +-- | Partition a list into elements that satisfy a predicate and elements that do not. +partition :: TypedTerm (a -> Bool) -> TypedTerm [a] -> TypedTerm ([a], [a]) +partition = primitive2 DefLists.partition + +-- | Create a list with a single element. +pure :: TypedTerm a -> TypedTerm [a] +pure = primitive1 DefLists.pure + +-- | Create a list with n copies of a value. +replicate :: AsTerm t a => TypedTerm Int -> t -> TypedTerm [a] +replicate n x = primitive2 DefLists.replicate n (asTerm x) + +-- | Reverse a list. +reverse :: TypedTerm [a] -> TypedTerm [a] +reverse = primitive1 DefLists.reverse + +-- | Create a single-element list. +singleton :: TypedTerm a -> TypedTerm [a] +singleton = primitive1 DefLists.singleton + +-- | Sort a list. +sort :: TypedTerm [a] -> TypedTerm [a] +sort = primitive1 DefLists.sort + +-- | Sort a list based on a key function. +sortOn :: TypedTerm (a -> b) -> TypedTerm [a] -> TypedTerm [a] +sortOn = primitive2 DefLists.sortOn + +-- | Split a list at the first element where predicate fails. +span :: TypedTerm (a -> Bool) -> TypedTerm [a] -> TypedTerm ([a], [a]) +span = primitive2 DefLists.span + +-- | Take the first n elements from a list. +take :: TypedTerm Int -> TypedTerm [a] -> TypedTerm [a] +take = primitive2 DefLists.take + +-- | Transpose a list of lists. +transpose :: TypedTerm [[a]] -> TypedTerm [[a]] +transpose = primitive1 DefLists.transpose + +-- | Decompose a list into its head and tail, returning Nothing if the list is empty. +uncons :: TypedTerm [a] -> TypedTerm (Maybe (a, [a])) +uncons = primitive1 DefLists.uncons + +-- | Zip two lists into pairs. +zip :: TypedTerm [a] -> TypedTerm [b] -> TypedTerm [(a, b)] +zip = primitive2 DefLists.zip + +-- | Zip two lists with a combining function. +zipWith :: TypedTerm (a -> b -> c) -> TypedTerm [a] -> TypedTerm [b] -> TypedTerm [c] +zipWith = primitive3 DefLists.zipWith diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Literals.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Literals.hs @@ -0,0 +1,234 @@ +-- | Phantom-typed term DSL for the hydra.lib.literals library + +module Hydra.Dsl.Meta.Lib.Literals where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms + +import qualified Data.ByteString as B +import qualified Data.Scientific as Sci +import Data.Int +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Literals as DefLiterals + + +-- | Convert a bigint (Integer) to a decimal (Scientific). +bigintToDecimal :: TypedTerm Integer -> TypedTerm Sci.Scientific +bigintToDecimal = primitive1 DefLiterals.bigintToDecimal + +-- | Convert a bigint (Integer) to an int16. +bigintToInt16 :: TypedTerm Integer -> TypedTerm Int16 +bigintToInt16 = primitive1 DefLiterals.bigintToInt16 + +-- | Convert a bigint (Integer) to an int32. +bigintToInt32 :: TypedTerm Integer -> TypedTerm Int +bigintToInt32 = primitive1 DefLiterals.bigintToInt32 + +-- | Convert a bigint (Integer) to an int64. +bigintToInt64 :: TypedTerm Integer -> TypedTerm Int64 +bigintToInt64 = primitive1 DefLiterals.bigintToInt64 + +-- | Convert a bigint (Integer) to an int8. +bigintToInt8 :: TypedTerm Integer -> TypedTerm Int8 +bigintToInt8 = primitive1 DefLiterals.bigintToInt8 + +-- | Convert a bigint (Integer) to a uint16. +bigintToUint16 :: TypedTerm Integer -> TypedTerm Int +bigintToUint16 = primitive1 DefLiterals.bigintToUint16 + +-- | Convert a bigint (Integer) to a uint32. +bigintToUint32 :: TypedTerm Integer -> TypedTerm Int64 +bigintToUint32 = primitive1 DefLiterals.bigintToUint32 + +-- | Convert a bigint (Integer) to a uint64. +bigintToUint64 :: TypedTerm Integer -> TypedTerm Integer +bigintToUint64 = primitive1 DefLiterals.bigintToUint64 + +-- | Convert a bigint (Integer) to a uint8. +bigintToUint8 :: TypedTerm Integer -> TypedTerm Int16 +bigintToUint8 = primitive1 DefLiterals.bigintToUint8 + +-- | Convert binary to a list of byte values (0-255). +binaryToBytes :: TypedTerm B.ByteString -> TypedTerm [Int] +binaryToBytes = primitive1 DefLiterals.binaryToBytes + +-- | Convert binary to string by base64 encoding. +binaryToString :: TypedTerm B.ByteString -> TypedTerm String +binaryToString = primitive1 DefLiterals.binaryToString + +-- | Convert a decimal (Scientific) to a bigint (Integer) by truncating toward zero. +decimalToBigint :: TypedTerm Sci.Scientific -> TypedTerm Integer +decimalToBigint = primitive1 DefLiterals.decimalToBigint + +-- | Convert a decimal (Scientific) to a float32 (Float). May lose precision. +decimalToFloat32 :: TypedTerm Sci.Scientific -> TypedTerm Float +decimalToFloat32 = primitive1 DefLiterals.decimalToFloat32 + +-- | Convert a decimal (Scientific) to a float64 (Double). May lose precision. +decimalToFloat64 :: TypedTerm Sci.Scientific -> TypedTerm Double +decimalToFloat64 = primitive1 DefLiterals.decimalToFloat64 + +-- | Convert a float32 (Float) to a decimal (Scientific). +float32ToDecimal :: TypedTerm Float -> TypedTerm Sci.Scientific +float32ToDecimal = primitive1 DefLiterals.float32ToDecimal + +-- | Convert a float32 (Float) to a float64 (Double). +float32ToFloat64 :: TypedTerm Float -> TypedTerm Double +float32ToFloat64 = primitive1 DefLiterals.float32ToFloat64 + +-- | Convert a float64 (Double) to a decimal (Scientific). +float64ToDecimal :: TypedTerm Double -> TypedTerm Sci.Scientific +float64ToDecimal = primitive1 DefLiterals.float64ToDecimal + +-- | Convert a float64 (Double) to a float32 (Float). May lose precision. +float64ToFloat32 :: TypedTerm Double -> TypedTerm Float +float64ToFloat32 = primitive1 DefLiterals.float64ToFloat32 + +-- | Convert an int16 to a bigint (Integer). +int16ToBigint :: TypedTerm Int16 -> TypedTerm Integer +int16ToBigint = primitive1 DefLiterals.int16ToBigint + +-- | Convert an int32 to a bigint (Integer). +int32ToBigint :: TypedTerm Int -> TypedTerm Integer +int32ToBigint = primitive1 DefLiterals.int32ToBigint + +-- | Convert an int64 to a bigint (Integer). +int64ToBigint :: TypedTerm Int64 -> TypedTerm Integer +int64ToBigint = primitive1 DefLiterals.int64ToBigint + +-- | Convert an int8 to a bigint (Integer). +int8ToBigint :: TypedTerm Int8 -> TypedTerm Integer +int8ToBigint = primitive1 DefLiterals.int8ToBigint + +-- | Parse a string to a bigint (Integer). +readBigint :: TypedTerm String -> TypedTerm (Maybe Integer) +readBigint = primitive1 DefLiterals.readBigint + +-- | Parse a string to a boolean. +readBoolean :: TypedTerm String -> TypedTerm (Maybe Bool) +readBoolean = primitive1 DefLiterals.readBoolean + +-- | Parse a string to a decimal (Scientific). +readDecimal :: TypedTerm String -> TypedTerm (Maybe Sci.Scientific) +readDecimal = primitive1 DefLiterals.readDecimal + +-- | Parse a string to a float32 (Float). +readFloat32 :: TypedTerm String -> TypedTerm (Maybe Float) +readFloat32 = primitive1 DefLiterals.readFloat32 + +-- | Parse a string to a float64 (Double). +readFloat64 :: TypedTerm String -> TypedTerm (Maybe Double) +readFloat64 = primitive1 DefLiterals.readFloat64 + +-- | Parse a string to an int16 (-32768 to 32767). +readInt16 :: TypedTerm String -> TypedTerm (Maybe Int16) +readInt16 = primitive1 DefLiterals.readInt16 + +-- | Parse a string to an int32. +readInt32 :: TypedTerm String -> TypedTerm (Maybe Int) +readInt32 = primitive1 DefLiterals.readInt32 + +-- | Parse a string to an int64. +readInt64 :: TypedTerm String -> TypedTerm (Maybe Int64) +readInt64 = primitive1 DefLiterals.readInt64 + +-- | Parse a string to an int8 (-128 to 127). +readInt8 :: TypedTerm String -> TypedTerm (Maybe Int8) +readInt8 = primitive1 DefLiterals.readInt8 + +-- | Parse a string literal. +readString :: TypedTerm String -> TypedTerm (Maybe String) +readString = primitive1 DefLiterals.readString + +-- | Parse a string to a uint16 (0 to 65535). +readUint16 :: TypedTerm String -> TypedTerm (Maybe Int) +readUint16 = primitive1 DefLiterals.readUint16 + +-- | Parse a string to a uint32 (0 to 4294967295). +readUint32 :: TypedTerm String -> TypedTerm (Maybe Int64) +readUint32 = primitive1 DefLiterals.readUint32 + +-- | Parse a string to a uint64 (0 to 18446744073709551615). +readUint64 :: TypedTerm String -> TypedTerm (Maybe Integer) +readUint64 = primitive1 DefLiterals.readUint64 + +-- | Parse a string to a uint8 (0 to 255). +readUint8 :: TypedTerm String -> TypedTerm (Maybe Int16) +readUint8 = primitive1 DefLiterals.readUint8 + +-- | Convert a bigint (Integer) to string. +showBigint :: TypedTerm Integer -> TypedTerm String +showBigint = primitive1 DefLiterals.showBigint + +-- | Convert a boolean to string. +showBoolean :: TypedTerm Bool -> TypedTerm String +showBoolean = primitive1 DefLiterals.showBoolean + +-- | Convert a decimal (Scientific) to string. +showDecimal :: TypedTerm Sci.Scientific -> TypedTerm String +showDecimal = primitive1 DefLiterals.showDecimal + +-- | Convert a float32 (Float) to string. +showFloat32 :: TypedTerm Float -> TypedTerm String +showFloat32 = primitive1 DefLiterals.showFloat32 + +-- | Convert a float64 (Double) to string. +showFloat64 :: TypedTerm Double -> TypedTerm String +showFloat64 = primitive1 DefLiterals.showFloat64 + +-- | Convert an int16 to string. +showInt16 :: TypedTerm Int16 -> TypedTerm String +showInt16 = primitive1 DefLiterals.showInt16 + +-- | Convert an int32 to string. +showInt32 :: TypedTerm Int -> TypedTerm String +showInt32 = primitive1 DefLiterals.showInt32 + +-- | Convert an int64 to string. +showInt64 :: TypedTerm Int64 -> TypedTerm String +showInt64 = primitive1 DefLiterals.showInt64 + +-- | Convert an int8 to string. +showInt8 :: TypedTerm Int8 -> TypedTerm String +showInt8 = primitive1 DefLiterals.showInt8 + +-- | Convert a string to a quoted string representation. +showString :: TypedTerm String -> TypedTerm String +showString = primitive1 DefLiterals.showString + +-- | Convert a uint16 to string. +showUint16 :: TypedTerm Int -> TypedTerm String +showUint16 = primitive1 DefLiterals.showUint16 + +-- | Convert a uint32 to string. +showUint32 :: TypedTerm Int64 -> TypedTerm String +showUint32 = primitive1 DefLiterals.showUint32 + +-- | Convert a uint64 to string. +showUint64 :: TypedTerm Integer -> TypedTerm String +showUint64 = primitive1 DefLiterals.showUint64 + +-- | Convert a uint8 to string. +showUint8 :: TypedTerm Int16 -> TypedTerm String +showUint8 = primitive1 DefLiterals.showUint8 + +-- | Convert string to binary by base64 decoding. +stringToBinary :: TypedTerm String -> TypedTerm B.ByteString +stringToBinary = primitive1 DefLiterals.stringToBinary + +-- | Convert a uint16 to a bigint (Integer). +uint16ToBigint :: TypedTerm Int -> TypedTerm Integer +uint16ToBigint = primitive1 DefLiterals.uint16ToBigint + +-- | Convert a uint32 to a bigint (Integer). +uint32ToBigint :: TypedTerm Int64 -> TypedTerm Integer +uint32ToBigint = primitive1 DefLiterals.uint32ToBigint + +-- | Convert a uint64 to a bigint (Integer). +uint64ToBigint :: TypedTerm Integer -> TypedTerm Integer +uint64ToBigint = primitive1 DefLiterals.uint64ToBigint + +-- | Convert a uint8 to a bigint (Integer). +uint8ToBigint :: TypedTerm Int16 -> TypedTerm Integer +uint8ToBigint = primitive1 DefLiterals.uint8ToBigint diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Logic.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Logic.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Logic.hs @@ -0,0 +1,40 @@ +-- | Phantom-typed term DSL for the hydra.lib.logic library + +{-# LANGUAGE FlexibleContexts #-} + +module Hydra.Dsl.Meta.Lib.Logic where + +import Hydra.Typed +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Logic as DefLogic + + +-- | Compute the logical AND of two boolean values. +and :: TypedTerm Bool -> TypedTerm Bool -> TypedTerm Bool +and = primitive2 DefLogic.and + +-- | Compute a conditional expression. +ifElse :: (AsTerm c Bool, AsTerm t a, AsTerm e a) => c -> t -> e -> TypedTerm a +ifElse cond t e = primitive3 DefLogic.ifElse (asTerm cond) (asTerm t) (asTerm e) + +-- | Compute the logical NOT of a boolean value. +not :: TypedTerm Bool -> TypedTerm Bool +not = primitive1 DefLogic.not + +-- | Compute the logical OR of two boolean values. +or :: TypedTerm Bool -> TypedTerm Bool -> TypedTerm Bool +or = primitive2 DefLogic.or + +---------------------------------------- +-- Helpers which are not primitives + +-- | Fold a list of booleans with logical AND, returning True for an empty list. +ands :: TypedTerm [Bool] -> TypedTerm Bool +ands terms = fold (primitive DefLogic.and) @@ true @@ terms + +-- | Fold a list of booleans with logical OR, returning False for an empty list. +ors :: TypedTerm [Bool] -> TypedTerm Bool +ors terms = fold (primitive DefLogic.or) @@ false @@ terms diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Maps.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Maps.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Maps.hs @@ -0,0 +1,95 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Phantom-typed term DSL for the hydra.lib.maps library + +module Hydra.Dsl.Meta.Lib.Maps where + +import Hydra.Typed +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms + +import Data.Map +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Maps as DefMaps + + +-- | Alter a value at a key using a function. +alter :: TypedTerm (Maybe v -> Maybe v) -> TypedTerm k -> TypedTerm (Map k v) -> TypedTerm (Map k v) +alter = primitive3 DefMaps.alter + +-- | Map a function over the keys and values of a map. +bimap :: TypedTerm (k1 -> k2) -> TypedTerm (v1 -> v2) -> TypedTerm (Map k1 v1) -> TypedTerm (Map k2 v2) +bimap = primitive3 DefMaps.bimap + +-- | Remove a key from a map. +delete :: TypedTerm k -> TypedTerm (Map k v) -> TypedTerm (Map k v) +delete = primitive2 DefMaps.delete + +-- | Get the values of a map. +elems :: TypedTerm (Map k v) -> TypedTerm [v] +elems = primitive1 DefMaps.elems + +-- | Create an empty map. +empty :: TypedTerm (Map k v) +empty = primitive DefMaps.empty + +-- | Filter a map based on values. +filter :: TypedTerm (v -> Bool) -> TypedTerm (Map k v) -> TypedTerm (Map k v) +filter = primitive2 DefMaps.filter + +-- | Filter a map based on key-value pairs. +filterWithKey :: TypedTerm (k -> v -> Bool) -> TypedTerm (Map k v) -> TypedTerm (Map k v) +filterWithKey = primitive2 DefMaps.filterWithKey + +-- | Lookup a value with a default. +findWithDefault :: AsTerm t v => t -> TypedTerm k -> TypedTerm (Map k v) -> TypedTerm v +findWithDefault def = primitive3 DefMaps.findWithDefault (asTerm def) + +-- | Create a map from a list of key-value pairs. +fromList :: TypedTerm [(k, v)] -> TypedTerm (Map k v) +fromList = primitive1 DefMaps.fromList + +-- | Insert a key-value pair into a map. +insert :: TypedTerm k -> TypedTerm v -> TypedTerm (Map k v) -> TypedTerm (Map k v) +insert = primitive3 DefMaps.insert + +-- | Get the keys of a map. +keys :: TypedTerm (Map k v) -> TypedTerm [k] +keys = primitive1 DefMaps.keys + +-- | Lookup a value in a map. +lookup :: AsTerm t k => t -> TypedTerm (Map k v) -> TypedTerm (Maybe v) +lookup k = primitive2 DefMaps.lookup (asTerm k) + +-- | Map a function over a map. +map :: AsTerm f (v1 -> v2) => f -> TypedTerm (Map k v1) -> TypedTerm (Map k v2) +map f = primitive2 DefMaps.map (asTerm f) + +-- | Map a function over the keys of a map. +mapKeys :: TypedTerm (k1 -> k2) -> TypedTerm (Map k1 v) -> TypedTerm (Map k2 v) +mapKeys = primitive2 DefMaps.mapKeys + +-- | Check if a key is present in a map. +member :: TypedTerm k -> TypedTerm (Map k v) -> TypedTerm Bool +member = primitive2 DefMaps.member + +-- | Check if a map is empty. +null :: TypedTerm (Map k v) -> TypedTerm Bool +null = primitive1 DefMaps.null + +-- | Create a map with a single key-value pair. +singleton :: TypedTerm k -> TypedTerm v -> TypedTerm (Map k v) +singleton = primitive2 DefMaps.singleton + +-- | Get the size of a map. +size :: TypedTerm (Map k v) -> TypedTerm Int +size = primitive1 DefMaps.size + +-- | Convert a map to a list of key-value pairs. +toList :: TypedTerm (Map k v) -> TypedTerm [(k, v)] +toList = primitive1 DefMaps.toList + +-- | Union two maps, with the first taking precedence. +union :: TypedTerm (Map k v) -> TypedTerm (Map k v) -> TypedTerm (Map k v) +union = primitive2 DefMaps.union diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Math.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Math.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Math.hs @@ -0,0 +1,202 @@ +-- | Phantom-typed term DSL for the hydra.lib.math library + +module Hydra.Dsl.Meta.Lib.Math where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Math as DefMath + + +-- | Return the absolute value. +abs :: Num a => TypedTerm a -> TypedTerm a +abs = primitive1 DefMath.abs + +-- | Return the arc cosine of x in radians. +acos :: TypedTerm Double -> TypedTerm Double +acos = primitive1 DefMath.acos + +-- | Return the inverse hyperbolic cosine of x. +acosh :: TypedTerm Double -> TypedTerm Double +acosh = primitive1 DefMath.acosh + +-- | Add two numbers. +add :: Num a => TypedTerm a -> TypedTerm a -> TypedTerm a +add = primitive2 DefMath.add + +-- | Add two Float64 numbers. +addFloat64 :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +addFloat64 = primitive2 DefMath.addFloat64 + +-- | Return the arc sine of x in radians. +asin :: TypedTerm Double -> TypedTerm Double +asin = primitive1 DefMath.asin + +-- | Return the inverse hyperbolic sine of x. +asinh :: TypedTerm Double -> TypedTerm Double +asinh = primitive1 DefMath.asinh + +-- | Return the arc tangent of x in radians. +atan :: TypedTerm Double -> TypedTerm Double +atan = primitive1 DefMath.atan + +-- | Return the arc tangent of y/x in radians, using signs to determine quadrant. +atan2 :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +atan2 = primitive2 DefMath.atan2 + +-- | Return the inverse hyperbolic tangent of x. +atanh :: TypedTerm Double -> TypedTerm Double +atanh = primitive1 DefMath.atanh + +-- | Return the ceiling of x as a float64. +-- DIVERGENCE FROM HASKELL: returns Double rather than Integer so that NaN and +-- ±Inf inputs propagate per IEEE 754. +ceiling :: TypedTerm Double -> TypedTerm Double +ceiling = primitive1 DefMath.ceiling + +-- | Return the cosine of x radians. +cos :: TypedTerm Double -> TypedTerm Double +cos = primitive1 DefMath.cos + +-- | Return the hyperbolic cosine of x. +cosh :: TypedTerm Double -> TypedTerm Double +cosh = primitive1 DefMath.cosh + +-- | Euler's number (e = 2.71828). +e :: TypedTerm Double +e = primitive DefMath.e + +-- | Check if an integer is even. +even :: Integral a => TypedTerm a -> TypedTerm Bool +even = primitive1 DefMath.even + +-- | Return e raised to the power x. +exp :: TypedTerm Double -> TypedTerm Double +exp = primitive1 DefMath.exp + +-- | Return the floor of x as a float64. +-- DIVERGENCE FROM HASKELL: returns Double rather than Integer so that NaN and +-- ±Inf inputs propagate per IEEE 754. +floor :: TypedTerm Double -> TypedTerm Double +floor = primitive1 DefMath.floor + +-- | Return the natural logarithm of x. +log :: TypedTerm Double -> TypedTerm Double +log = primitive1 DefMath.log + +-- | Return the logarithm of x to the given base. +logBase :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +logBase = primitive2 DefMath.logBase + +-- | Return the maximum of two values. +max :: Ord a => TypedTerm a -> TypedTerm a -> TypedTerm a +max = primitive2 DefMath.max + +-- | Divide two integers using integer division, returning Nothing on division by zero. +maybeDiv :: TypedTerm Int -> TypedTerm Int -> TypedTerm (Maybe Int) +maybeDiv = primitive2 DefMath.maybeDiv + +-- | Mathematical modulo, returning Nothing on division by zero. +maybeMod :: TypedTerm Int -> TypedTerm Int -> TypedTerm (Maybe Int) +maybeMod = primitive2 DefMath.maybeMod + +-- | Return the predecessor (x - 1), returning Nothing on minBound. +maybePred :: TypedTerm Int -> TypedTerm (Maybe Int) +maybePred = primitive1 DefMath.maybePred + +-- | Integer remainder, returning Nothing on division by zero. +maybeRem :: TypedTerm Int -> TypedTerm Int -> TypedTerm (Maybe Int) +maybeRem = primitive2 DefMath.maybeRem + +-- | Return the successor (x + 1), returning Nothing on maxBound. +maybeSucc :: TypedTerm Int -> TypedTerm (Maybe Int) +maybeSucc = primitive1 DefMath.maybeSucc + +-- | Return the minimum of two values. +min :: Ord a => TypedTerm a -> TypedTerm a -> TypedTerm a +min = primitive2 DefMath.min + +-- | Multiply two numbers. +mul :: Num a => TypedTerm a -> TypedTerm a -> TypedTerm a +mul = primitive2 DefMath.mul + +-- | Multiply two Float64 numbers. +mulFloat64 :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +mulFloat64 = primitive2 DefMath.mulFloat64 + +-- | Negate a number. +negate :: Num a => TypedTerm a -> TypedTerm a +negate = primitive1 DefMath.negate + +-- | Negate a Float64 number. +negateFloat64 :: TypedTerm Double -> TypedTerm Double +negateFloat64 = primitive1 DefMath.negateFloat64 + +-- | Check if an integer is odd. +odd :: Integral a => TypedTerm a -> TypedTerm Bool +odd = primitive1 DefMath.odd + +-- | Pi (pi = 3.14159). +pi :: TypedTerm Double +pi = primitive DefMath.pi + +-- | Return x raised to the power y. +pow :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +pow = primitive2 DefMath.pow + +-- | Generate a range of values from start to end (inclusive). +range :: Enum a => TypedTerm a -> TypedTerm a -> TypedTerm [a] +range start end = primitive2 DefMath.range start end + +-- | Return x rounded to the nearest integer, as a float64. +-- DIVERGENCE FROM HASKELL: returns Double rather than Integer so that NaN and +-- ±Inf inputs propagate per IEEE 754. +round :: TypedTerm Double -> TypedTerm Double +round = primitive1 DefMath.round + +-- | Round a float32 to n significant digits. +roundFloat32 :: TypedTerm Int -> TypedTerm Float -> TypedTerm Float +roundFloat32 = primitive2 DefMath.roundFloat32 + +-- | Round a float64 to n significant digits. +roundFloat64 :: TypedTerm Int -> TypedTerm Double -> TypedTerm Double +roundFloat64 = primitive2 DefMath.roundFloat64 + +-- | Return the sign of a number (-1, 0, or 1). +signum :: Num a => TypedTerm a -> TypedTerm a +signum = primitive1 DefMath.signum + +-- | Return the sine of x radians. +sin :: TypedTerm Double -> TypedTerm Double +sin = primitive1 DefMath.sin + +-- | Return the hyperbolic sine of x. +sinh :: TypedTerm Double -> TypedTerm Double +sinh = primitive1 DefMath.sinh + +-- | Return the square root of x. +sqrt :: TypedTerm Double -> TypedTerm Double +sqrt = primitive1 DefMath.sqrt + +-- | Subtract two numbers. +sub :: Num a => TypedTerm a -> TypedTerm a -> TypedTerm a +sub = primitive2 DefMath.sub + +-- | Subtract two Float64 numbers. +subFloat64 :: TypedTerm Double -> TypedTerm Double -> TypedTerm Double +subFloat64 = primitive2 DefMath.subFloat64 + +-- | Return the tangent of x radians. +tan :: TypedTerm Double -> TypedTerm Double +tan = primitive1 DefMath.tan + +-- | Return the hyperbolic tangent of x. +tanh :: TypedTerm Double -> TypedTerm Double +tanh = primitive1 DefMath.tanh + +-- | Return x truncated (towards zero), as a float64. +-- DIVERGENCE FROM HASKELL: returns Double rather than Integer so that NaN and +-- ±Inf inputs propagate per IEEE 754. +truncate :: TypedTerm Double -> TypedTerm Double +truncate = primitive1 DefMath.truncate diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Optionals.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Optionals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Optionals.hs @@ -0,0 +1,63 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Phantom-typed term DSL for the hydra.lib.optionals library + +module Hydra.Dsl.Meta.Lib.Optionals where + +import Hydra.Typed +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Optionals as DefOptionals + + +-- | Apply a function to an argument (applicative). +apply :: TypedTerm (Maybe (a -> b)) -> TypedTerm (Maybe a) -> TypedTerm (Maybe b) +apply = primitive2 DefOptionals.apply + +-- | Chain operations on optional values, handling absent cases automatically. +bind :: TypedTerm (Maybe a) -> TypedTerm (a -> Maybe b) -> TypedTerm (Maybe b) +bind = primitive2 DefOptionals.bind + +-- | Handle an optional value with the optional value as the first argument. +-- The default and function arguments accept anything coercible to a term (AsTerm), +-- mirroring the ergonomics of the former 'maybe' eliminator. +cases :: (AsTerm t1 b, AsTerm t2 (a -> b)) => TypedTerm (Maybe a) -> t1 -> t2 -> TypedTerm b +cases m def f = primitive3 DefOptionals.cases m (asTerm def) (asTerm f) + +-- | Filter out absent values from a list. +cat :: TypedTerm [Maybe a] -> TypedTerm [a] +cat = primitive1 DefOptionals.cat + +-- | Compose two optional-returning functions (Kleisli composition). +compose :: TypedTerm (a -> Maybe b) -> TypedTerm (b -> Maybe c) -> TypedTerm (a -> Maybe c) +compose = primitive2 DefOptionals.compose + +-- | Get a value from an optional value, or return a default value. +fromOptional :: TypedTerm a -> TypedTerm (Maybe a) -> TypedTerm a +fromOptional = primitive2 DefOptionals.fromOptional + +-- | Check if a value is present. +isGiven :: TypedTerm (Maybe a) -> TypedTerm Bool +isGiven = primitive1 DefOptionals.isGiven + +-- | Check if a value is absent. +isNone :: TypedTerm (Maybe a) -> TypedTerm Bool +isNone = primitive1 DefOptionals.isNone + +-- | Map a function over an optional value. +map :: AsTerm f (a -> b) => f -> TypedTerm (Maybe a) -> TypedTerm (Maybe b) +map f = primitive2 DefOptionals.map (asTerm f) + +-- | Map a function over a list and collect present results. +mapOptional :: TypedTerm (a -> Maybe b) -> TypedTerm [a] -> TypedTerm [b] +mapOptional = primitive2 DefOptionals.mapOptional + +-- | Lift a value into the optional type. +pure :: TypedTerm a -> TypedTerm (Maybe a) +pure = primitive1 DefOptionals.pure + +-- | Convert an optional value to a list: a present value becomes [x], an absent value becomes []. +toList :: TypedTerm (Maybe a) -> TypedTerm [a] +toList = primitive1 DefOptionals.toList diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Pairs.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Pairs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Pairs.hs @@ -0,0 +1,22 @@ +-- | Phantom-typed term DSL for the hydra.lib.pairs library + +module Hydra.Dsl.Meta.Lib.Pairs where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Pairs as DefPairs + + +-- | Map over both elements of a pair. +bimap :: TypedTerm (a -> c) -> TypedTerm (b -> d) -> TypedTerm (a, b) -> TypedTerm (c, d) +bimap = primitive3 DefPairs.bimap + +-- | Get the first element of a pair. +first :: TypedTerm (a, b) -> TypedTerm a +first = primitive1 DefPairs.first + +-- | Get the second element of a pair. +second :: TypedTerm (a, b) -> TypedTerm b +second = primitive1 DefPairs.second diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Regex.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Regex.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Regex.hs @@ -0,0 +1,34 @@ +-- | Phantom-typed term DSL for the hydra.lib.regex library + +module Hydra.Dsl.Meta.Lib.Regex where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Regex as DefRegex + + +-- | Find the first substring matching a regex pattern. +find :: TypedTerm String -> TypedTerm String -> TypedTerm (Maybe String) +find = primitive2 DefRegex.find + +-- | Find all non-overlapping substrings matching a regex pattern. +findAll :: TypedTerm String -> TypedTerm String -> TypedTerm [String] +findAll = primitive2 DefRegex.findAll + +-- | Check whether an entire string matches a regex pattern. +matches :: TypedTerm String -> TypedTerm String -> TypedTerm Bool +matches = primitive2 DefRegex.matches + +-- | Replace the first occurrence of a regex pattern with a replacement string. +replace :: TypedTerm String -> TypedTerm String -> TypedTerm String -> TypedTerm String +replace = primitive3 DefRegex.replace + +-- | Replace all non-overlapping occurrences of a regex pattern with a replacement string. +replaceAll :: TypedTerm String -> TypedTerm String -> TypedTerm String -> TypedTerm String +replaceAll = primitive3 DefRegex.replaceAll + +-- | Split a string by a regex pattern. +split :: TypedTerm String -> TypedTerm String -> TypedTerm [String] +split = primitive2 DefRegex.split diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Sets.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Sets.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Sets.hs @@ -0,0 +1,71 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Phantom-typed term DSL for the hydra.lib.sets library + +module Hydra.Dsl.Meta.Lib.Sets where + +import Hydra.Typed +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms + +import Data.Set +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Sets as DefSets + + +-- | Delete an element from a set. +delete :: AsTerm t a => t -> TypedTerm (Set a) -> TypedTerm (Set a) +delete x = primitive2 DefSets.delete (asTerm x) + +-- | Compute the difference of two sets. +difference :: TypedTerm (Set a) -> TypedTerm (Set a) -> TypedTerm (Set a) +difference = primitive2 DefSets.difference + +-- | Create an empty set. +empty :: TypedTerm (Set a) +empty = primitive DefSets.empty + +-- | Create a set from a list. +fromList :: AsTerm t [a] => t -> TypedTerm (Set a) +fromList xs = primitive1 DefSets.fromList (asTerm xs) + +-- | Insert an element into a set. +insert :: TypedTerm a -> TypedTerm (Set a) -> TypedTerm (Set a) +insert = primitive2 DefSets.insert + +-- | Compute the intersection of two sets. +intersection :: TypedTerm (Set a) -> TypedTerm (Set a) -> TypedTerm (Set a) +intersection = primitive2 DefSets.intersection + +-- | Map a function over a set. +map :: TypedTerm (a -> b) -> TypedTerm (Set a) -> TypedTerm (Set b) +map = primitive2 DefSets.map + +-- | Check if an element is in a set. +member :: TypedTerm a -> TypedTerm (Set a) -> TypedTerm Bool +member = primitive2 DefSets.member + +-- | Check if a set is empty. +null :: TypedTerm (Set a) -> TypedTerm Bool +null = primitive1 DefSets.null + +-- | Create a singleton set. +singleton :: TypedTerm a -> TypedTerm (Set a) +singleton = primitive1 DefSets.singleton + +-- | Get the size of a set. +size :: TypedTerm (Set a) -> TypedTerm Int +size = primitive1 DefSets.size + +-- | Convert a set to a list. +toList :: TypedTerm (Set a) -> TypedTerm [a] +toList = primitive1 DefSets.toList + +-- | Compute the union of two sets. +union :: TypedTerm (Set a) -> TypedTerm (Set a) -> TypedTerm (Set a) +union = primitive2 DefSets.union + +-- | Compute the union of multiple sets. +unions :: TypedTerm [Set a] -> TypedTerm (Set a) +unions = primitive1 DefSets.unions diff --git a/src/main/haskell/Hydra/Dsl/Meta/Lib/Strings.hs b/src/main/haskell/Hydra/Dsl/Meta/Lib/Strings.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Lib/Strings.hs @@ -0,0 +1,68 @@ +-- | Phantom-typed term DSL for the hydra.lib.strings library + +module Hydra.Dsl.Meta.Lib.Strings where + +import Hydra.Typed +import Hydra.Dsl.Meta.Phantoms +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Strings as DefStrings + + +-- | Concatenate a list of strings into a single string. +cat :: TypedTerm [String] -> TypedTerm String +cat = primitive1 DefStrings.cat + +-- | Concatenate two strings. +cat2 :: TypedTerm String -> TypedTerm String -> TypedTerm String +cat2 = primitive2 DefStrings.cat2 + +-- | Convert a list of Unicode code points to a string. +fromList :: TypedTerm [Int] -> TypedTerm String +fromList = primitive1 DefStrings.fromList + +-- | Join a list of strings with a separator between each element. +intercalate :: TypedTerm String -> TypedTerm [String] -> TypedTerm String +intercalate = primitive2 DefStrings.intercalate + +-- | Return the length of a string. +length :: TypedTerm String -> TypedTerm Int +length = primitive1 DefStrings.length + +-- | Split a string into lines. +lines :: TypedTerm String -> TypedTerm [String] +lines = primitive1 DefStrings.lines + +-- | Get the Unicode code point of the character at a specific index, returning Nothing if out of bounds. +maybeCharAt :: TypedTerm Int -> TypedTerm String -> TypedTerm (Maybe Int) +maybeCharAt = primitive2 DefStrings.maybeCharAt + +-- | Check whether a string is empty. +null :: TypedTerm String -> TypedTerm Bool +null = primitive1 DefStrings.null + +-- | Split a string on a delimiter string. +splitOn :: TypedTerm String -> TypedTerm String -> TypedTerm [String] +splitOn = primitive2 DefStrings.splitOn + +-- | Convert a string to a list of Unicode code points. +toList :: TypedTerm String -> TypedTerm [Int] +toList = primitive1 DefStrings.toList + +-- | Convert a string to lowercase. +toLower :: TypedTerm String -> TypedTerm String +toLower = primitive1 DefStrings.toLower + +-- | Convert a string to uppercase. +toUpper :: TypedTerm String -> TypedTerm String +toUpper = primitive1 DefStrings.toUpper + +-- | Join a list of strings with newlines, appending a trailing newline. +unlines :: TypedTerm [String] -> TypedTerm String +unlines = primitive1 DefStrings.unlines + +-- Helpers + +-- | Concatenate a Haskell list of string terms into a single string. +concat :: [TypedTerm String] -> TypedTerm String +concat strings = primitive DefStrings.cat @@ list strings diff --git a/src/main/haskell/Hydra/Dsl/Meta/Literals.hs b/src/main/haskell/Hydra/Dsl/Meta/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Literals.hs @@ -0,0 +1,80 @@ +-- | A DSL for constructing literal terms using Haskell's built-in datatypes + +module Hydra.Dsl.Meta.Literals where + +import Hydra.Typed +import qualified Hydra.Dsl.Terms as Terms + +import Data.Int +import qualified Data.ByteString as B +import qualified Data.Scientific as Sci + + +-- Binary is now properly represented as ByteString +type Binary = B.ByteString + +bigint :: Integer -> TypedTerm Integer +bigint = TypedTerm . Terms.bigint + +binary :: Binary -> TypedTerm Binary +binary = TypedTerm . Terms.binary + +bool :: Bool -> TypedTerm Bool +bool = TypedTerm . Terms.boolean + +boolean :: Bool -> TypedTerm Bool +boolean = bool + +char :: Char -> TypedTerm Int +char = TypedTerm . Terms.char + +decimal :: Sci.Scientific -> TypedTerm Sci.Scientific +decimal = TypedTerm . Terms.decimal + +double :: Double -> TypedTerm Double +double = float64 + +false :: TypedTerm Bool +false = bool False + +float :: Float -> TypedTerm Float +float = float32 + +float32 :: Float -> TypedTerm Float +float32 = TypedTerm . Terms.float32 + +float64 :: Double -> TypedTerm Double +float64 = TypedTerm . Terms.float64 + +int :: Int -> TypedTerm Int +int = int32 + +int16 :: Int16 -> TypedTerm Int16 +int16 = TypedTerm . Terms.int16 + +int32 :: Int -> TypedTerm Int +int32 = TypedTerm . Terms.int32 + +int64 :: Int64 -> TypedTerm Int64 +int64 = TypedTerm . Terms.int64 + +int8 :: Int8 -> TypedTerm Int8 +int8 = TypedTerm . Terms.int8 + +string :: String -> TypedTerm String +string = TypedTerm . Terms.string + +true :: TypedTerm Bool +true = bool True + +uint16 :: Int -> TypedTerm Int +uint16 = TypedTerm . Terms.uint16 + +uint32 :: Int64 -> TypedTerm Int64 +uint32 = TypedTerm . Terms.uint32 + +uint64 :: Integer -> TypedTerm Integer +uint64 = TypedTerm . Terms.uint64 + +uint8 :: Int16 -> TypedTerm Int16 +uint8 = TypedTerm . Terms.uint8 diff --git a/src/main/haskell/Hydra/Dsl/Meta/Phantoms.hs b/src/main/haskell/Hydra/Dsl/Meta/Phantoms.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Phantoms.hs @@ -0,0 +1,487 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Term-level DSL which makes use of phantom types. Use this DSL for defining programs as opposed to data type definitions. +-- The phantom types provide static type checking in Haskell prior to Hydra's runtime type checking. +module Hydra.Dsl.Meta.Phantoms ( + module Hydra.Dsl.Meta.Phantoms, + module Hydra.Dsl.Meta.Literals, + module Hydra.Dsl.AsTerm, +) where + +import Hydra.Kernel +import Hydra.Dsl.AsTerm +import Hydra.Dsl.Meta.Common +import Hydra.Dsl.Meta.Literals +import qualified Hydra.Dsl.Annotations as Ann +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Show.Core as ShowCore +import Hydra.Encoding (encodeBindingName) +import Hydra.Decoding (decodeBindingName) + +import Prelude hiding ((++)) +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Set as S +import qualified Hydra.Dsl.Prims as Prims +import qualified Hydra.Lib.Eithers as DefEithers +import qualified Hydra.Lib.Lists as DefLists +import qualified Hydra.Lib.Math as DefMath +import qualified Hydra.Lib.Optionals as DefOptionals +import qualified Hydra.Lib.Strings as DefStrings + + +-- Operators + +infixr 0 ~> +(~>) :: String -> TypedTerm x -> TypedTerm (a -> b) +name ~> body = lambda name body + +infixl 1 <~ +(<~) :: String -> TypedTerm a -> TypedTerm b -> TypedTerm b +name <~ value = let1 name value + +infixl 1 <<~ +(<<~) :: AsTerm t (Either e a) => String -> t -> TypedTerm (Either e b) -> TypedTerm (Either e b) +name <<~ def = eitherBind name (asTerm def) + +-- | Function composition operator: f <.> g creates a function that applies g then f +-- Example: toString <.> increment +-- Accepts TypedTerm or TypedBinding for both operands (via AsTerm) +(<.>) :: (AsTerm f (b -> c), AsTerm g (a -> b)) => f -> g -> TypedTerm (a -> c) +f <.> g = compose (asTerm f) (asTerm g) + +-- | Function application operator: function @@ argument +-- Example: add @@ int32 1 +-- Accepts TypedTerm or TypedBinding for both operands (via AsTerm) +(@@) :: (AsTerm f (a -> b), AsTerm g a) => f -> g -> TypedTerm b +fun @@ arg = apply (asTerm fun) (asTerm arg) + +(++) :: (AsTerm f String, AsTerm g String) => f -> g -> TypedTerm String +f ++ g = primitive2 (Prims.primName DefStrings.cat2) (asTerm f) (asTerm g) + +-- | Field definition operator for records: name>: value +-- Example: "name">: string "John" +-- Accepts TypedTerm or TypedBinding (via AsTerm) +infixr 0 >: +(>:) :: AsTerm t a => String -> t -> Field +name>: term = Field (Name name) (unTypedTerm $ asTerm term) + +-- | Field definition operator with pre-constructed name: fname>>: value +-- Example: _Person_name>>: string "John" +-- Accepts TypedTerm or TypedBinding (via AsTerm) +infixr 0 >>: +(>>:) :: AsTerm t a => Name -> t -> Field +fname >>: d = field fname (asTerm d) + +-- | Add an annotation to a term +-- Example: annot (Name "deprecated") (Just (boolean True)) myFunction +annot :: Name -> Maybe Term -> TypedTerm a -> TypedTerm a +annot key mvalue (TypedTerm term) = TypedTerm $ Ann.annotateTerm key mvalue term + +-- | Apply a function to an argument +-- Example: apply (var "add") (int32 1) +apply :: TypedTerm (a -> b) -> TypedTerm a -> TypedTerm b +apply (TypedTerm lhs) (TypedTerm rhs) = TypedTerm $ Terms.apply lhs rhs + + + +-- | Apply a named case match to an argument +-- Example: cases resultTypeName myResult Nothing [onSuccess, onError] +-- See also: 'match' +cases :: Name -> TypedTerm a -> Maybe (TypedTerm b) -> [Field] -> TypedTerm b +cases name arg dflt fields = TypedTerm $ Terms.apply (Terms.match name (unTypedTerm <$> dflt) fields) (unTypedTerm arg) + +-- | Compose two functions (g then f) +-- Example: compose (var "stringLength") (var "toString") +-- Accepts TypedTerm or TypedBinding for both operands (via AsTerm) +compose :: (AsTerm f (b -> c), AsTerm g (a -> b)) => f -> g -> TypedTerm (a -> c) +compose f g = TypedTerm $ Terms.compose (unTypedTerm $ asTerm f) (unTypedTerm $ asTerm g) + +-- | Create a constant function that always returns the same value +-- Example: constant true +-- Accepts TypedTerm or TypedBinding (via AsTerm) +constant :: AsTerm t a => t -> TypedTerm (b -> a) +constant t = TypedTerm $ Terms.constant (unTypedTerm $ asTerm t) + +-- | Get a reference to a decoder function in hydra.decode.core for a given type name +-- The decoder takes a graph context and a term, returning either a decoding error or the decoded value +decoderFor :: Name -> TypedTerm (Graph -> Term -> Prelude.Either DecodingError a) +decoderFor typeName = var $ unName $ decodeBindingName typeName + +-- | Create a definition in a module +-- Example: definitionInModule myModule "addInts" (lambda "x" (lambda "y" (add @@ var "x" @@ var "y"))) +definitionInModule :: Module -> String -> TypedTerm a -> TypedTermDefinition a +definitionInModule mod = definitionInModuleName $ moduleName mod + +-- | Create a definition in a namespace +-- Example: definitionInModuleName (ModuleName "com.example") "addInts" myFunction +definitionInModuleName :: ModuleName -> String -> TypedTerm a -> TypedTermDefinition a +definitionInModuleName ns lname = TypedTermDefinition $ unqualifyName $ QualifiedName (Just ns) lname + +-- | Add documentation to a term +-- Example: doc "Adds two integers" addFunction +-- Accepts TypedTerm or TypedBinding (via AsTerm) +doc :: AsTerm t a => String -> t -> TypedTerm a +doc s t = TypedTerm $ setTermDescription (Just s) (unTypedTerm $ asTerm t) + +-- | Add documentation with line wrapping at the specified width +-- Example: docWrapped 80 "This is a long documentation string that will be wrapped..." myFunction +docWrapped :: Int -> String -> TypedTerm a -> TypedTerm a +docWrapped len = doc . wrapLine len + +-- | Bind over Either: extracts the Right value into a variable, short-circuiting on Left +eitherBind :: AsTerm t (Either e a) => String -> t -> TypedTerm (Either e b) -> TypedTerm (Either e b) +eitherBind v def body = primitive2 (Prims.primName DefEithers.bind) (asTerm def) $ lambda v $ body + +-- | Convert a typed element to an untyped element (legacy name, prefer 'toBinding') +-- Example: el (definitionInModule myModule "addInts" myFunction) +el :: TypedBinding a -> Binding +el = toBinding + +encodedBinary :: TypedTerm String -> TypedTerm Term +encodedBinary = encodedLiteral . inject _Literal _Literal_binary + +encodedBoolean :: TypedTerm Bool -> TypedTerm Term +encodedBoolean = encodedLiteral . inject _Literal _Literal_boolean + +encodedCase :: AsTerm t (a -> Term) => Name -> Name -> t -> Field +encodedCase tname fname enc = field fname $ "v" ~> encodedVariant tname fname (enc @@ var "v") + +encodedEither :: TypedTerm (Prelude.Either a b) -> TypedTerm Term +encodedEither = inject _Term _Term_either + +encodedField :: Name -> TypedTerm Term -> TypedTerm Term +encodedField fname term = encodedFieldRaw (encodedName fname) term + +encodedFieldRaw :: TypedTerm Name -> TypedTerm Term -> TypedTerm Term +encodedFieldRaw (TypedTerm fname) (TypedTerm term) = TypedTerm $ Terms.record _Field [ + Field _Field_name fname, + Field _Field_term term] + +encodedFloatValue :: TypedTerm FloatValue -> TypedTerm Term +encodedFloatValue = encodedLiteral . inject _Literal _Literal_float + +encodedInjection :: Name -> Name -> TypedTerm Term -> TypedTerm Term +encodedInjection tname fname term = TypedTerm $ Terms.record _Injection [ + field _Injection_typeName $ encodedName tname, + field _Injection_field $ encodedField fname term] + +encodedInt32 :: TypedTerm Int -> TypedTerm Term +encodedInt32 v = encodedIntegerValue $ inject _IntegerValue _IntegerValue_int32 v + +encodedIntegerValue :: TypedTerm IntegerValue -> TypedTerm Term +encodedIntegerValue = encodedLiteral . inject _Literal _Literal_integer + +encodedList :: TypedTerm [a] -> TypedTerm Term +encodedList = inject _Term _Term_list + +encodedLiteral :: TypedTerm Literal -> TypedTerm Term +encodedLiteral = inject _Term _Term_literal + +encodedMap :: TypedTerm (M.Map k v) -> TypedTerm Term +encodedMap = inject _Term _Term_map + +encodedName :: Name -> TypedTerm Name +encodedName = wrap _Name . string . unName + +encodedOptional :: TypedTerm (Maybe a) -> TypedTerm Term +encodedOptional = inject _Term _Term_optional + +encodedPair :: TypedTerm (a, b) -> TypedTerm Term +encodedPair = inject _Term _Term_pair + +encodedRecord :: Name -> [Field] -> TypedTerm Term +encodedRecord tname fields = TypedTerm $ Terms.inject _Term _Term_record $ Terms.record _Record [ + field _Record_typeName $ encodedName tname, + field _Record_fields $ list (encField <$> fields)] + where + encField (Field fname term) = encodedField fname $ TypedTerm term + +encodedSet :: TypedTerm (S.Set a) -> TypedTerm Term +encodedSet = inject _Term _Term_set + +encodedString :: TypedTerm String -> TypedTerm Term +encodedString = encodedLiteral . inject _Literal _Literal_string + +encodedUnion :: TypedTerm Term -> TypedTerm Term +encodedUnion = inject _Term _Term_inject + +encodedUnit :: TypedTerm Term +encodedUnit = injectUnit _Term _Term_unit + +encodedVariant :: Name -> Name -> TypedTerm Term -> TypedTerm Term +encodedVariant tname fname term = encodedUnion $ encodedInjection tname fname term + +encodedWrappedTerm :: Name -> TypedTerm Term -> TypedTerm Term +encodedWrappedTerm name = encodedWrappedTermRaw (encodedName name) + +encodedWrappedTermRaw :: TypedTerm Name -> TypedTerm Term -> TypedTerm Term +encodedWrappedTermRaw (TypedTerm name) (TypedTerm term) = TypedTerm $ Terms.inject _Term _Term_wrap $ Terms.record _WrappedTerm [ + Field _WrappedTerm_typeName name, + Field _WrappedTerm_body term] + +-- | Get a reference to an encoder function in hydra.encode.core for a given type name +encoderFor :: Name -> TypedTerm (a -> Term) +encoderFor typeName = var $ unName $ encodeBindingName typeName + +-- | Create a field with the given name and value +-- Example: field (Name "age") (int32 30) +field :: Name -> TypedTerm a -> Field +field fname (TypedTerm val) = Field fname val + +-- | Mark a type as first-class +-- Example: firstClassType (record ...) +firstClassType :: TypedTerm Type -> TypedTerm Type +firstClassType typ = annot keyFirstClassType (Just $ Terms.boolean True) typ + +-- | Create a fold function to process lists +-- Example: fold (lambda "acc" (lambda "x" (add @@ var "acc" @@ var "x"))) +fold :: AsTerm t (b -> a -> b) => t -> TypedTerm (b -> [a] -> b) +fold f = (primitive (Prims.primName DefLists.foldl)) @@ asTerm f + +-- | Identity function that returns its argument unchanged +-- Example: identity +identity :: TypedTerm (a -> a) +identity = TypedTerm Terms.identity + +-- | Create a union injection +-- Example: inject (Name "Result") (Name "success") (string "ok") +inject :: (AsName t, AsName f) => t -> f -> TypedTerm a -> TypedTerm b +inject n fn (TypedTerm term) = TypedTerm $ Terms.inject (asName n) (asName fn) term + +-- | Create a function that injects its argument into a union variant +-- Example: injectLambda (Name "Result") (Name "success") +injectLambda :: Name -> Name -> TypedTerm (a -> b) +injectLambda name fname = lambda "injected_" $ inject name fname $ var "injected_" + +-- | Create a unit variant of a union +-- Example: injectUnit (Name "Result") (Name "success") +injectUnit :: (AsName t, AsName f) => t -> f -> TypedTerm a +injectUnit n fn = TypedTerm $ Terms.inject (asName n) (asName fn) Terms.unit + +-- | Create a 'Just' optional value +-- Example: just (string "found") +-- Accepts TypedTerm or TypedBinding (via AsTerm) +just :: AsTerm t a => t -> TypedTerm (Maybe a) +just t = TypedTerm $ Terms.just (unTypedTerm $ asTerm t) + +-- | Function that wraps a value in 'Just' +-- Example: just_ @@ myValue +just_ :: TypedTerm (a -> Maybe a) +just_ = TypedTerm $ Terms.lambda "just_" $ Terms.just $ Terms.var "just_" + +-- | Create a lambda function with one parameter +-- Example: lambda "x" (var "add" @@ var "x" @@ int32 1) +lambda :: String -> TypedTerm x -> TypedTerm (a -> b) +lambda v (TypedTerm body) = TypedTerm $ Terms.lambda v body + +-- | Create a multi-parameter lambda function +-- Example: lambdas ["x", "y"] (add @@ var "x" @@ var "y") +lambdas :: [String] -> TypedTerm x -> TypedTerm (a -> b) +lambdas params (TypedTerm body) = TypedTerm $ Terms.lambdas params body + +-- | Create a 'Left' either value +-- Example: left (string "error") +left :: TypedTerm a -> TypedTerm (Either a b) +left (TypedTerm term) = TypedTerm $ Terms.left term + +-- | Function that wraps a value in 'Left' +-- Example: left_ @@ myValue +left_ :: TypedTerm (a -> Either a b) +left_ = TypedTerm $ Terms.lambda "left_" $ Terms.left $ Terms.var "left_" + +let1 :: String -> TypedTerm a -> TypedTerm b -> TypedTerm b +let1 name (TypedTerm value) (TypedTerm env) = TypedTerm $ TermLet $ Let [Binding (Name name) value Nothing] env + +-- | Create a let expression with multiple bindings +-- Example: lets ["x">: int32 1, "y">: int32 2] (var "add" @@ var "x" @@ var "y") +lets :: [Field] -> TypedTerm a -> TypedTerm a +lets fields (TypedTerm env) = TypedTerm $ TermLet $ Let (toBinding <$> fields) env + where + toBinding (Field name value) = Binding name value Nothing + +-- | Create a list of terms +-- Example: list [int32 1, int32 2, int32 3] +-- Accepts TypedTerm or TypedBinding elements (via AsTerm) +list :: AsTerm t a => [t] -> TypedTerm [a] +list els = TypedTerm $ Terms.list (unTypedTerm . asTerm <$> els) + +-- | Create a map/dictionary term +-- Example: map (M.fromList [(string "a", int32 1), (string "b", int32 2)]) +map :: M.Map (TypedTerm a) (TypedTerm b) -> TypedTerm (M.Map a b) +map = TypedTerm . Terms.map . M.fromList . fmap fromTypedTerm . M.toList + where + fromTypedTerm (TypedTerm k, TypedTerm v) = (k, v) + +-- | Create a pattern match on a union term +-- Example: match (Name "Result") (Just $ string "what?") ["success">: string "yay", "error">: string "boo"] +match :: AsName n => n -> Maybe (TypedTerm b) -> [Field] -> TypedTerm (a -> b) +match n dflt fields = TypedTerm $ Terms.match (asName n) (unTypedTerm <$> dflt) fields + +-- | Lift a Haskell Name value to a phantom-typed TypedTerm Name +nameLift :: Name -> TypedTerm Name +nameLift (Name n) = wrap _Name $ string n + +-- | Create a 'Nothing' optional value +-- Example: nothing +nothing :: TypedTerm (Maybe a) +nothing = TypedTerm Terms.nothing + +-- | Create an optional value from a Maybe +-- Example: opt (Just myValue) +opt :: Maybe (TypedTerm a) -> TypedTerm (Maybe a) +opt mc = TypedTerm $ Terms.optional (unTypedTerm <$> mc) + +optCases :: AsTerm f (a -> b) => TypedTerm (Maybe a) -> TypedTerm b -> f -> TypedTerm b +optCases arg ifNothing ifJust = primitive3 (Name "hydra.lib.optionals.cases") arg ifNothing (asTerm ifJust) + +-- | Create a pair +-- Example: pair (string "age") (int32 32) +-- Accepts TypedTerm or TypedBinding (via AsTerm) +pair :: (AsTerm t1 a, AsTerm t2 b) => t1 -> t2 -> TypedTerm (a, b) +pair l r = TypedTerm $ Terms.pair (unTypedTerm $ asTerm l) (unTypedTerm $ asTerm r) + +-- | Primitive function by name +-- Example: primitive (Name "hydra.lib.strings.length") +primitive :: Terms.ToPrimName n => n -> TypedTerm a +primitive = TypedTerm . Terms.primitive + +-- | Apply a primitive function to one argument +-- Example: primitive1 DefMath.abs (int32 (-5)) +primitive1 :: Terms.ToPrimName n => n -> TypedTerm a -> TypedTerm b +primitive1 n (TypedTerm a) = TypedTerm $ Terms.primitive n Terms.@@ a + +-- | Apply a primitive function to two arguments +-- Example: primitive2 DefMath.add (int32 2) (int32 3) +primitive2 :: Terms.ToPrimName n => n -> TypedTerm a -> TypedTerm b -> TypedTerm c +primitive2 n (TypedTerm a) (TypedTerm b) = TypedTerm $ Terms.primitive n Terms.@@ a Terms.@@ b + +-- | Apply a primitive function to three arguments +-- Example: primitive3 DefStrings.replace (string "hello") (string "e") (string "a") +primitive3 :: Terms.ToPrimName n => n -> TypedTerm a -> TypedTerm b -> TypedTerm c -> TypedTerm d +primitive3 n (TypedTerm a) (TypedTerm b) (TypedTerm c) = TypedTerm $ Terms.primitive n Terms.@@ a Terms.@@ b Terms.@@ c + +-- | Extract a field from a record +-- Example: project (Name "Person") (Name "name") +project :: (AsName t, AsName f) => t -> f -> TypedTerm (a -> b) +project n fn = TypedTerm $ Terms.project (asName n) (asName fn) + +-- | Create a record with named fields +-- Example: record (Name "Person") [field (Name "name") (string "John"), field (Name "age") (int32 30)] +record :: AsName n => n -> [Field] -> TypedTerm a +record n fields = TypedTerm $ Terms.record (asName n) fields + +-- | Reify a Haskell-level meta-function over phantom-typed terms into a first-class +-- term-level function. See also 'reify2' for the binary form. +-- Example: @reify Literals.showInt32@ has type @TypedTerm (Int -> String)@ +reify :: (TypedTerm a -> TypedTerm b) -> TypedTerm (a -> b) +reify f = case (unTypedTerm $ f $ var "x") of + TermApplication (Application lhs _) -> TypedTerm lhs + TermEither (Prelude.Left _) -> lambda "x" $ TypedTerm $ TermEither $ Prelude.Left $ Terms.var "x" + TermEither (Prelude.Right _) -> lambda "x" $ TypedTerm $ TermEither $ Prelude.Right $ Terms.var "x" + TermOptional (Just _) -> primitive (Prims.primName DefOptionals.pure) + TermInject (Injection tname (Field fname _)) -> lambda "x" $ inject tname fname $ var "x" + TermWrap (WrappedTerm tname _) -> lambda "x" $ wrap tname $ var "x" + +-- | Reify a binary Haskell-level meta-function over phantom-typed terms into a +-- first-class term-level function. See also 'reify' for the unary form. +-- Example: @reify2 (\\x y -> Maths.add x (Maths.mul x y))@ +reify2 :: (TypedTerm a -> TypedTerm b -> TypedTerm c) -> TypedTerm (a -> b -> c) +reify2 f = case (unTypedTerm $ f (var "x") (var "y")) of + TermApplication (Application (TermApplication (Application lhs _)) _) -> TypedTerm lhs + t -> TypedTerm $ Terms.string $ "unexpected term as binary function: " <> ShowCore.term t + + + +-- | Create a 'Right' either value +-- Example: right (int32 42) +right :: TypedTerm b -> TypedTerm (Either a b) +right (TypedTerm term) = TypedTerm $ Terms.right term + +-- | Function that wraps a value in 'Right' +-- Example: right_ @@ myValue +right_ :: TypedTerm (b -> Either a b) +right_ = TypedTerm $ Terms.lambda "right_" $ Terms.right $ Terms.var "right_" + +-- | Create a set of terms +-- Example: set [string "a", string "b", string "c"] +set :: [TypedTerm a] -> TypedTerm (S.Set a) +set = TypedTerm . Terms.set . S.fromList . fmap unTypedTerm + +-- | Convert a typed binding to an untyped Binding for use in module element lists +-- Example: toBinding functionArity +toBinding :: TypedBinding a -> Binding +toBinding (TypedBinding name (TypedTerm term)) = Binding name term Nothing + +-- | Convert a phantom-typed term definition to a Definition for use in module definition lists +-- Example: toDefinition functionArity +toDefinition :: TypedTermDefinition a -> Definition +toDefinition (TypedTermDefinition name (TypedTerm term)) = DefinitionTerm $ TermDefinition name Nothing Nothing term + +-- | Convert a phantom-typed term definition to a primitive Definition, using the term body as the +-- declarative default implementation. The TermSignature describes the primitive's logical type. +-- isPure / isTotal default to True; use withImpurity / withPartiality to flag exceptions. +-- The 'comments' argument (second-to-last) is a list of long-form prose notes elaborating the one-line +-- description, one element per logical observation (e.g. semantics, edge cases, totality, host correspondence); +-- the default-implementation argument stays last because its value is typically large. +-- Example: toPrimitive "logical AND" andSig [] and_ +toPrimitive :: String -> TermSignature -> [String] -> TypedTermDefinition a -> Definition +toPrimitive description sig comments (TypedTermDefinition name (TypedTerm term)) = + DefinitionPrimitive $ PrimitiveDefinition name (primitiveMetadata description comments) sig True True (Just term) + +-- | Convert a Name to a primitive Definition with no default implementation. Used for primitives +-- whose meaning is host-native and not expressible as a Hydra term (e.g. currentUnixTimeSeconds). +-- The trailing 'comments' argument is a list of long-form prose notes, one element per logical observation. +-- Example: toPrimitiveNoDefault "Current UNIX time, in seconds" sig (Name "hydra.lib.math.currentUnixTimeSeconds") [] +toPrimitiveNoDefault :: String -> TermSignature -> Name -> [String] -> Definition +toPrimitiveNoDefault description sig name comments = + DefinitionPrimitive $ PrimitiveDefinition name (primitiveMetadata description comments) sig True True Nothing + +-- | Build the entity metadata for a primitive from its (always-present) one-line description and +-- long-form comments. Folds the former PrimitiveDefinition.description/comments fields into +-- EntityMetadata without data loss: description -> metadata.description, comments -> metadata.comments. +-- Each comments element is one logical observation, kept distinct rather than concatenated. +primitiveMetadata :: String -> [String] -> Maybe EntityMetadata +primitiveMetadata description comments = + Just (EntityMetadata (Just description) comments [] Nothing) + + + +-- | Convert a typed binding to a term Definition for use in module definition lists +-- Example: toTermDefinition functionArity +toTermDefinition :: TypedBinding a -> Definition +toTermDefinition (TypedBinding name (TypedTerm term)) = DefinitionTerm $ TermDefinition name Nothing Nothing term + + +triple :: TypedTerm a -> TypedTerm b -> TypedTerm c -> TypedTerm (a, b, c) +triple (TypedTerm a) (TypedTerm b) (TypedTerm c) = TypedTerm $ Terms.triple a b c + +tuple4 :: TypedTerm a -> TypedTerm b -> TypedTerm c -> TypedTerm d -> TypedTerm (a, b, c, d) +tuple4 (TypedTerm a) (TypedTerm b) (TypedTerm c) (TypedTerm d) = TypedTerm $ Terms.tuple4 a b c d + +tuple5 :: TypedTerm a -> TypedTerm b -> TypedTerm c -> TypedTerm d -> TypedTerm e -> TypedTerm (a, b, c, d, e) +tuple5 (TypedTerm a) (TypedTerm b) (TypedTerm c) (TypedTerm d) (TypedTerm e) = TypedTerm $ Terms.tuple5 a b c d e + +-- | Unit value (empty record) +unit :: TypedTerm a +unit = TypedTerm Terms.unit + +-- | Unsafe phantom type cast. Used during bootstrap when changing Module field types. +unsafeCast :: TypedTerm a -> TypedTerm b +unsafeCast (TypedTerm t) = TypedTerm t + +-- | Create an unwrap function for a wrapped type +-- Example: unwrap (Name "Email") +unwrap :: AsName n => n -> TypedTerm (a -> b) +unwrap = TypedTerm . Terms.unwrap . asName + +-- | Create a variable reference +-- Example: var "x" +var :: String -> TypedTerm a +var v = TypedTerm $ Terms.var v + +-- | Create a wrapped term (instance of a newtype) +-- Example: wrap (Name "Email") (string "user@example.com") +-- Note: the phantom types provide no guarantee of type safety in this case +wrap :: AsName n => n -> TypedTerm a -> TypedTerm b +wrap n (TypedTerm term) = TypedTerm $ Terms.wrap (asName n) term diff --git a/src/main/haskell/Hydra/Dsl/Meta/Tabular.hs b/src/main/haskell/Hydra/Dsl/Meta/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Tabular.hs @@ -0,0 +1,14 @@ +-- | DSL helpers for constructing tabular (relational) schemas + +module Hydra.Dsl.Meta.Tabular where + +import Hydra.Core +import Hydra.Relational +import Hydra.Tabular + + +columnType :: String -> Type -> ColumnType +columnType name typ = ColumnType (ColumnName name) typ + +tableType :: String -> [ColumnType] -> TableType +tableType name columns = TableType (RelationName name) columns diff --git a/src/main/haskell/Hydra/Dsl/Meta/Terms.hs b/src/main/haskell/Hydra/Dsl/Meta/Terms.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Terms.hs @@ -0,0 +1,528 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | A domain-specific language for constructing term-encoded Hydra terms in Haskell; +-- these functions enable you to build terms (programs) which build terms. +module Hydra.Dsl.Meta.Terms ( + module Hydra.Dsl.Meta.Base, + module Hydra.Dsl.Meta.Terms, +) where + +import Hydra.Kernel +import qualified Hydra.Dsl.Terms as Terms +import qualified Hydra.Dsl.Meta.Core as Core +import qualified Hydra.Encode.Core as EncodeCore +import Hydra.Dsl.Meta.Base +import qualified Hydra.Dsl.Meta.Phantoms as Phantoms +import qualified Hydra.Dsl.Meta.Lib.Maps as Maps + +import qualified Data.ByteString as B +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Scientific as Sci +import qualified Data.Set as S +import qualified Data.Maybe as Y +import Data.Int +import Prelude hiding (map, product, sum) + + +-- Operators + +-- | Function composition operator for term-encoded terms: f <.> g creates a function that applies g then f +-- Example: var "stringLength" <.> var "toString" +(<.>) :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +f <.> g = compose f g + +-- | Function application operator for term-encoded terms +-- Example: fun @@ arg +(@@) :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +f @@ x = apply f x + +-- | Attach a map of annotations to a term-encoded term, wrapping the map as a +-- TermMap annotation per Hydra's convention (#386). Each Name key is lifted +-- to a TermVariable in the resulting TermMap. +-- Distinct from 'Phantoms.annot' (which attaches a single annotation by key). +-- Example: annots (Phantoms.map M.empty) (int32 42) +annots :: TypedTerm (M.Map Name Term) -> TypedTerm Term -> TypedTerm Term +annots annMap term = Core.termAnnotated $ Core.annotatedTerm term (annotationMapToTerm annMap) + +-- | Create a term-encoded annotated term (term with type annotations). +-- The map argument is wrapped as a TermMap annotation per Hydra's convention. +-- Example: annotated (int32 42) (Phantoms.map M.empty) +annotated :: TypedTerm Term -> TypedTerm (M.Map Name Term) -> TypedTerm Term +annotated term annMap = Core.termAnnotated $ Core.annotatedTerm term (annotationMapToTerm annMap) + +-- | Lift a term-encoded Map to a term-encoded TermMap with each +-- Name key wrapped as a TermVariable. The canonical encoding for Hydra's +-- annotation map convention after #386. +annotationMapToTerm :: TypedTerm (M.Map Name Term) -> TypedTerm Term +annotationMapToTerm m = Core.termMap + (Maps.mapKeys (Phantoms.lambda "n" (Core.termVariable (Phantoms.var "n"))) m) + +annotatedTerm :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +annotatedTerm body ann = inject (Core.nameLift _Term) "annotated" $ record (Core.nameLift _AnnotatedTerm) [ + _AnnotatedTerm_body>>: body, + _AnnotatedTerm_annotation>>: ann] + +-- | Apply a term-encoded function to a term-encoded argument +-- Example: apply (var "add") (int32 1) +apply :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +apply func arg = Core.termApplication $ Core.application func arg + +-- | Create a term-encoded unlimited precision integer +-- Example: bigint 42 +bigint :: Integer -> TypedTerm Term +bigint = bigintLift . TypedTerm . Terms.bigint + +-- | Lift a TypedTerm Integer to a term-encoded bigint literal +-- Example: bigintLift (varPhantom "x" :: TypedTerm Integer) +bigintLift :: TypedTerm Integer -> TypedTerm Term +bigintLift = Core.termLiteral . Core.literalInteger . Core.integerValueBigint + +-- | Create a term-encoded binary (byte string) literal +-- Example: binary (B.pack [0x48, 0x65, 0x6C, 0x6C, 0x6F]) +binary :: B.ByteString -> TypedTerm Term +binary = binaryLift . TypedTerm . Terms.binary + +-- | Lift a TypedTerm ByteString to a term-encoded binary literal +binaryLift :: TypedTerm B.ByteString -> TypedTerm Term +binaryLift = Core.termLiteral . Core.literalBinary + +-- | Create a term-encoded boolean literal +-- Example: boolean True +boolean :: Bool -> TypedTerm Term +boolean = booleanLift . TypedTerm . Terms.boolean + +-- | Lift a TypedTerm Bool to a term-encoded boolean literal +-- Example: booleanLift $ Phantoms.true +booleanLift :: TypedTerm Bool -> TypedTerm Term +booleanLift = Core.termLiteral . Core.literalBoolean + +-- | Create a meta-level term encoding a boolean literal +-- Example: booleanTerm True creates a term that *represents* the boolean True +booleanTerm :: Bool -> TypedTerm Term +booleanTerm b = inject (Core.nameLift _Term) "literal" $ inject (Core.nameLift _Literal) "boolean" $ boolean b + +-- | Create a term-encoded character literal via int32 +-- Example: char 'A' +char :: Char -> TypedTerm Term +char = int32 . ord + where + ord = fromEnum + +-- | Convert a Comparison enum value to a term-encoded term +-- Example: comparison ComparisonEqualTo +comparison :: Comparison -> TypedTerm Term +comparison t = case t of + ComparisonEqualTo -> Phantoms.injectUnit _Comparison _Comparison_equalTo + ComparisonLessThan -> Phantoms.injectUnit _Comparison _Comparison_lessThan + ComparisonGreaterThan -> Phantoms.injectUnit _Comparison _Comparison_greaterThan + + +-- | Term-encoded function composition (apply g then f) +-- Example: compose f g creates a function that applies g then f +compose :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +compose f g = lambda "arg_" $ f @@ (g @@ var "arg_") + +-- | Create a term-encoded constant function that always returns the same term-encoded value +-- Example: constant (int32 42) +constant :: TypedTerm Term -> TypedTerm Term +constant = lambda ignoredVariable + +-- | Create a term-encoded arbitrary-precision exact decimal literal +-- Example: decimal 42 +decimal :: Sci.Scientific -> TypedTerm Term +decimal = decimalLift . TypedTerm . Terms.decimal + +-- | Lift a TypedTerm Scientific to a term-encoded decimal literal +decimalLift :: TypedTerm Sci.Scientific -> TypedTerm Term +decimalLift = Core.termLiteral . Core.literalDecimal + +-- | Term-encoded boolean false literal +false :: TypedTerm Term +false = boolean False + +-- | Create a term-encoded field with the given name and term-encoded value +-- Example: field "age" (int32 30) +field :: String -> TypedTerm Term -> TypedTerm Field +field s = Core.field (name s) + +-- | Create a term-encoded floating-point literal with specified precision +-- Example: float (FloatValueFloat32 3.14) +float :: TypedTerm FloatValue -> TypedTerm Term +float = Core.termLiteral . Core.literalFloat + +-- | Create a term-encoded 32-bit floating point literal +-- Example: float32 3.14 +float32 :: Float -> TypedTerm Term +float32 = float32Lift . TypedTerm . Terms.float32 + +-- | Lift a TypedTerm Float to a term-encoded float32 literal +-- Example: float32Lift (varPhantom "x" :: TypedTerm Float) +float32Lift :: TypedTerm Float -> TypedTerm Term +float32Lift = Core.termLiteral . Core.literalFloat . Core.floatValueFloat32 + +-- | Create a term-encoded 64-bit floating point literal +-- Example: float64 3.14159 +float64 :: Double -> TypedTerm Term +float64 = float64Lift . TypedTerm . Terms.float64 + +-- | Lift a TypedTerm Float to a term-encoded float64 literal +-- Example: float64Lift (varPhantom "x" :: TypedTerm Float) +float64Lift :: TypedTerm Double -> TypedTerm Term +float64Lift = Core.termLiteral . Core.literalFloat . Core.floatValueFloat64 + +-- | Term-encoded identity function +-- Example: identity +identity :: TypedTerm Term +identity = lambda "x_" $ var "x_" + +-- | Create a term-encoded union injection +-- Example: inject (name "Result") "success" (int32 42) +inject :: AsTerm t Name => t -> String -> TypedTerm Term -> TypedTerm Term +inject tname fname = Core.termInject . Core.injection (asTerm tname) . Core.field (name fname) + +injectPhantom :: Name -> Name -> TypedTerm Term -> TypedTerm Term +injectPhantom tname fname term = Core.termInject $ Core.injection (Core.nameLift tname) $ Core.field (Core.nameLift fname) term + +injectUnit :: AsTerm t Name => t -> String -> TypedTerm Term +injectUnit tname fname = inject tname fname unit + +injectUnitPhantom :: Name -> Name -> TypedTerm Term +injectUnitPhantom tname fname = injectPhantom tname fname Core.termUnit + +-- | Create a term-encoded 16-bit signed integer literal +-- Example: int16 32767 +int16 :: Int16 -> TypedTerm Term +int16 = int16Lift . TypedTerm . Terms.int16 + +-- | Lift a TypedTerm Int16 to a term-encoded int16 literal +-- Example: int16Lift (varPhantom "x" :: TypedTerm Int16) +int16Lift :: TypedTerm Int16 -> TypedTerm Term +int16Lift = Core.termLiteral . Core.literalInteger . Core.integerValueInt16 + +-- | Create a meta-level term encoding a 16-bit signed integer literal +-- Example: int16Term 100 creates a term that *represents* the int16 literal 100 +int16Term :: Int16 -> TypedTerm Term +int16Term n = inject (Core.nameLift _Term) "literal" $ + inject (Core.nameLift _Literal) "integer" $ + inject (Core.nameLift _IntegerValue) "int16" $ int16 n + +-- | Create a term-encoded 32-bit signed integer literal +-- Example: int32 42 +int32 :: Int -> TypedTerm Term +int32 = int32Lift . TypedTerm . Terms.int32 + +-- | Lift a TypedTerm Int to a term-encoded int32 literal +-- Example: int32Lift (varPhantom "x" :: TypedTerm Int) +int32Lift :: TypedTerm Int -> TypedTerm Term +int32Lift = Core.termLiteral . Core.literalInteger . Core.integerValueInt32 + +-- | Create a meta-level term encoding a 32-bit signed integer literal +-- Example: int32Term 42 creates a term that *represents* the int32 literal 42 +int32Term :: Int -> TypedTerm Term +int32Term n = inject (Core.nameLift _Term) "literal" $ + inject (Core.nameLift _Literal) "integer" $ + inject (Core.nameLift _IntegerValue) "int32" $ int32 n + +-- | Create a term-encoded 64-bit signed integer literal +-- Example: int64 9223372036854775807 +int64 :: Int64 -> TypedTerm Term +int64 = int64Lift . TypedTerm . Terms.int64 + +-- | Lift a TypedTerm Int64 to a term-encoded int64 literal +-- Example: int64Lift (varPhantom "x" :: TypedTerm Int64) +int64Lift :: TypedTerm Int64 -> TypedTerm Term +int64Lift = Core.termLiteral . Core.literalInteger . Core.integerValueInt64 + +-- | Create a meta-level term encoding a 64-bit signed integer literal +-- Example: int64Term 137 creates a term that *represents* the int64 literal 137 +int64Term :: Int64 -> TypedTerm Term +int64Term n = inject (Core.nameLift _Term) "literal" $ + inject (Core.nameLift _Literal) "integer" $ + inject (Core.nameLift _IntegerValue) "int64" $ int64 n + +-- | Create a term-encoded 8-bit signed integer literal +-- Example: int8 127 +int8 :: Int8 -> TypedTerm Term +int8 = int8Lift . TypedTerm . Terms.int8 + +-- | Lift a TypedTerm Int8 to a term-encoded int8 literal +-- Example: int8Lift (varPhantom "x" :: TypedTerm Int8) +int8Lift :: TypedTerm Int8 -> TypedTerm Term +int8Lift = Core.termLiteral . Core.literalInteger . Core.integerValueInt8 + +-- | Create a term-encoded integer literal with specified bit width +-- Example: integer (IntegerValueInt32 42) +integer :: TypedTerm IntegerValue -> TypedTerm Term +integer = Core.termLiteral . Core.literalInteger + +-- | Create a term-encoded 'Just' optional value +-- Example: just (string "found") +just :: TypedTerm Term -> TypedTerm (Maybe Term) +just = Phantoms.just + +-- | Create a term-encoded lambda function with one parameter +-- Example: lambda "x" (var "add" @@ var "x" @@ int32 1) +lambda :: String -> TypedTerm Term -> TypedTerm Term +lambda var body = Core.termLambda $ Core.lambda (name var) Phantoms.nothing body + +-- | Create a term-encoded lambda with a type annotation +-- Example: lambdaTyped "x" T.int32 (var "x") +lambdaTyped :: String -> TypedTerm Type -> TypedTerm Term -> TypedTerm Term +lambdaTyped param dom body = Core.termLambda $ Core.lambda (name param) (Phantoms.just dom) body + +-- | Create a term-encoded multi-parameter lambda function (curried form) +-- Example: lambdas ["x", "y"] (var "add" @@ var "x" @@ var "y") +lambdas :: [String] -> TypedTerm Term -> TypedTerm Term +lambdas params body = case params of + [] -> body + (h:rest) -> Core.termLambda $ Core.lambda (name h) Phantoms.nothing $ lambdas rest body + +-- | Create a term-encoded left either value +-- Example: left (string "error") +left :: TypedTerm Term -> TypedTerm Term +left t = Core.termEither $ Phantoms.left t + +-- | Create a term-encoded let expression with multiple bindings +-- Example: lets ["x">: int32 1, "y">: int32 2] (var "add" @@ var "x" @@ var "y") +lets :: [(TypedTerm Name, TypedTerm Term)] -> TypedTerm Term -> TypedTerm Term +lets pairs body = Core.termLet $ Core.let_ (Phantoms.list $ toBinding pairs) body + where + toBinding = fmap (\(n, t) -> Core.binding n t Phantoms.nothing) + +-- | Create a term-encoded let expression with type annotations on bindings +-- Example: letsTyped [("x", int32 1, T.mono T.int32)] (var "x") +letsTyped :: [(String, TypedTerm Term, TypedTerm TypeScheme)] -> TypedTerm Term -> TypedTerm Term +letsTyped bindings body = Core.termLet $ Core.let_ (Phantoms.list $ toBinding bindings) body + where + toBinding = fmap (\(n, t, ts) -> Core.binding (name n) t (Phantoms.just ts)) + +-- | Create a term-encoded list +-- Example: list [int32 1, int32 2, int32 3] +list :: [TypedTerm Term] -> TypedTerm Term +list = Core.termList . Phantoms.list + +-- | Create a term-encoded literal from a Literal value +-- Example: literal (LiteralInteger (IntegerValueInt32 42)) +literal :: TypedTerm Literal -> TypedTerm Term +literal = Core.termLiteral + +-- | Create a term-encoded map/dictionary +-- Example: map (fromList [(string "key", int32 42)]) +map :: TypedTerm (M.Map Term Term) -> TypedTerm Term +map = Core.termMap + +mapTerm1 :: TypedTerm (M.Map Term Term) -> TypedTerm Term +mapTerm1 m = inject (Core.nameLift _Term) "map" $ Core.termMap m + +-- | Create a term-encoded pattern match on a union +-- Example: match (name "Result") nothing ["success">: int32 42, "error">: string "fail"] +match :: AsTerm t Name => t -> TypedTerm (Maybe Term) -> [(TypedTerm Name, TypedTerm Term)] -> TypedTerm Term +match tname def pairs = Core.termCases + $ Core.caseStatement (asTerm tname) def $ Phantoms.list $ toCaseAlternative pairs + where + toCaseAlternative = fmap (\(n, t) -> Core.caseAlternative n t) + +--meta :: TypedTerm a -> TypedTerm Term +--meta (TypedTerm term) = TypedTerm $ EncodeCore.term term + +metaref :: TypedTermDefinition a -> TypedTerm Term +metaref (TypedTermDefinition name _) = Core.termVariable $ Core.nameLift name + +-- | Create a meta-level term encoding a Name +-- Example: nameTerm "foo" creates a term that *represents* the name "foo" +nameTerm :: String -> TypedTerm Term +nameTerm s = wrap (Core.nameLift _Name) $ string s + +-- | Create a term-encoded 'Nothing' optional value +nothing :: TypedTerm (Maybe Term) +nothing = Phantoms.nothing + +-- | Create a term-encoded optional value from a Maybe +-- Example: optional (just (int32 42)) +optional :: TypedTerm (Maybe Term) -> TypedTerm Term +optional = Core.termOptional + +-- | Create a term-encoded pair +-- Example: pair (string "name") (int32 42) +pair :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +pair t1 t2 = Core.termPair $ Phantoms.pair t1 t2 + +-- | Create a term-encoded reference to a primitive function. +-- Uses termVariable; the name resolves via graphPrimitives fallthrough. +-- Example: primitive DefStrings.length +primitive :: Terms.ToPrimName n => n -> TypedTerm Term +primitive = Core.termVariable . TypedTerm . EncodeCore.name . Terms.toPrimName + +-- | Create a term-encoded field projection function +-- Example: project (name "Person") (name "firstName") +project :: (AsTerm t Name, AsTerm f Name) => t -> f -> TypedTerm Term +project tname fname = Core.termProject + $ Core.projection (asTerm tname) (asTerm fname) + +-- | Create a term-encoded record with named fields +-- Example: record (name "Person") ["name">: string "John", "age">: int32 30] +record :: AsTerm t Name => t -> [(TypedTerm Name, TypedTerm Term)] -> TypedTerm Term +record name pairs = Core.termRecord $ Core.record (asTerm name) $ Phantoms.list (toField <$> pairs) + where + toField (n, t) = Core.field n t + +recordLift :: Name -> [(TypedTerm Name, TypedTerm Term)] -> TypedTerm Term +recordLift name pairs = record (TypedTerm $ EncodeCore.name name) pairs + +-- | Create a term-encoded right either value +-- Example: right (int32 42) +right :: TypedTerm Term -> TypedTerm Term +right t = Core.termEither $ Phantoms.right t + +-- | Create a term-encoded set +-- Example: set [string "a", string "b", string "c"] +set :: [TypedTerm Term] -> TypedTerm Term +set els = Core.termSet $ TypedTerm $ TermSet $ S.fromList (unTypedTerm <$> els) + +-- | Create a term-encoded string literal +-- Example: string "hello world" +string :: String -> TypedTerm Term +string = stringLift . TypedTerm . Terms.string + +-- | Lift a TypedTerm String to a term-encoded string literal +-- Example: stringLift $ Phantoms.string "hello world" +stringLift :: TypedTerm String -> TypedTerm Term +stringLift = Core.termLiteral . Core.literalString + +stringTerm :: String -> TypedTerm Term +stringTerm s = inject (Core.nameLift _Term) "literal" $ inject (Core.nameLift _Literal) "string" $ string s + +-- | Create a term-encoded 3-tuple using nested pairs +-- Example: triple (int32 1) (string "test") (boolean True) +triple :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term +triple t1 t2 t3 = pair t1 (pair t2 t3) + +-- | Term-encoded boolean true literal +true :: TypedTerm Term +true = boolean True + +-- | Create a term-encoded tuple with multiple components using nested pairs +-- Example: tuple [string "name", int32 42, boolean True] +tuple :: [TypedTerm Term] -> TypedTerm Term +tuple [] = unit +tuple [a] = a +tuple [a, b] = pair a b +tuple (a:rest) = pair a (tuple rest) + +-- | Create a term-encoded 2-tuple (same as pair) +-- Example: tuple2 (string "name") (int32 42) +tuple2 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term +tuple2 = pair + +-- | Create a term-encoded 4-tuple using nested pairs +-- Example: tuple4 (int32 1) (string "test") (boolean True) (float32 3.14) +tuple4 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term +tuple4 t1 t2 t3 t4 = pair t1 (pair t2 (pair t3 t4)) + +-- | Create a term-encoded 5-tuple using nested pairs +-- Example: tuple5 (int32 1) (string "a") (boolean True) (float32 3.14) (int32 42) +tuple5 :: TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term -> TypedTerm Term +tuple5 t1 t2 t3 t4 t5 = pair t1 (pair t2 (pair t3 (pair t4 t5))) + +-- | Create a term-encoded type application +-- Example: tyapp (list []) T.int32 +tyapp :: TypedTerm Term -> TypedTerm Type -> TypedTerm Term +tyapp term typ = Core.termTypeApplication $ Core.typeApplicationTerm term typ + +-- | Apply multiple type arguments to a term +-- Example: tyapps (pair (int32 1) (string "a")) [T.int32, T.string] +tyapps :: TypedTerm Term -> [TypedTerm Type] -> TypedTerm Term +tyapps = L.foldl tyapp + +-- | Create a term-encoded type lambda (System F) +-- Example: tylam "t0" (lambda "x" $ var "x") +tylam :: String -> TypedTerm Term -> TypedTerm Term +tylam var body = Core.termTypeLambda $ Core.typeLambda (name var) body + +-- | Create multiple term-encoded type lambdas +-- Example: tylams ["t0", "t1"] (lambda "x" $ var "x") +tylams :: [String] -> TypedTerm Term -> TypedTerm Term +tylams vars body = L.foldl (\b v -> Core.termTypeLambda $ Core.typeLambda (name v) b) body $ L.reverse vars + +-- | Apply type arguments to a polymorphic term (same as tyapps) +-- Example: typeApplication (list []) [T.int32] +typeApplication :: TypedTerm Term -> [TypedTerm Type] -> TypedTerm Term +typeApplication = tyapps + +-- | Create term-encoded type lambda(s) (same as tylams) +-- Example: typeLambda ["t0"] (lambda "x" $ var "x") +typeLambda :: [String] -> TypedTerm Term -> TypedTerm Term +typeLambda = tylams + +-- | Create a term-encoded 16-bit unsigned integer literal +-- Example: uint16 65535 +uint16 :: Int -> TypedTerm Term +uint16 = uint16Lift . TypedTerm . Terms.uint16 + +-- | Lift a TypedTerm Int to a term-encoded uint16 literal +-- Example: uint16Lift (varPhantom "x" :: TypedTerm Int) +uint16Lift :: TypedTerm Int -> TypedTerm Term +uint16Lift = Core.termLiteral . Core.literalInteger . Core.integerValueUint16 + +-- | Create a term-encoded 32-bit unsigned integer literal +-- Example: uint32 4294967295 +uint32 :: Int64 -> TypedTerm Term +uint32 = uint32Lift . TypedTerm . Terms.uint32 + +-- | Lift a TypedTerm Int64 to a term-encoded uint32 literal +uint32Lift :: TypedTerm Int64 -> TypedTerm Term +uint32Lift = Core.termLiteral . Core.literalInteger . Core.integerValueUint32 + +-- | Create a term-encoded 64-bit unsigned integer literal +-- Example: uint64 18446744073709551615 +uint64 :: Integer -> TypedTerm Term +uint64 = uint64Lift . TypedTerm . Terms.uint64 + +-- | Lift a TypedTerm Integer to a term-encoded uint64 literal +-- Example: uint64Lift (varPhantom "x" :: TypedTerm Integer) +uint64Lift :: TypedTerm Integer -> TypedTerm Term +uint64Lift = Core.termLiteral . Core.literalInteger . Core.integerValueUint64 + +-- | Create a term-encoded 8-bit unsigned integer literal +-- Example: uint8 255 +uint8 :: Int16 -> TypedTerm Term +uint8 = uint8Lift . TypedTerm . Terms.uint8 + +uint8Lift :: TypedTerm Int16 -> TypedTerm Term +uint8Lift = Core.termLiteral . Core.literalInteger . Core.integerValueUint8 + +-- | Create a term-encoded unit value +-- Example: unit +unit :: TypedTerm Term +unit = Core.termUnit + +-- | Create a term-encoded unwrap function for a wrapped type +-- Example: unwrap (name "Email") +unwrap :: AsTerm t Name => t -> TypedTerm Term +unwrap = Core.termUnwrap . asTerm + +-- | Create a term-encoded variable reference from a string +-- Example: var "x" +var :: String -> TypedTerm Term +var = Core.termVariable . name + +-- | Create a term-encoded variable reference from a Name +-- Example: varName (Name "x") +varName :: Name -> TypedTerm Term +varName (Name n) = Core.termVariable $ TypedTerm $ Terms.string n + +-- | Create a phantom-typed variable reference from a Name +-- Example: varNamePhantom (Name "x") :: TypedTerm Int +varNamePhantom :: Name -> TypedTerm a +varNamePhantom = TypedTerm . TermVariable + +-- | Maps a string to a phantom-typed variable term +-- Example: varPhantom "x" :: TypedTerm Int +varPhantom :: String -> TypedTerm a +varPhantom = TypedTerm . TermVariable . Name + +-- | Create a term-encoded wrapped term (newtype) +-- Example: wrap (name "Email") (string "user@example.com") +wrap :: AsTerm t Name => t -> TypedTerm Term -> TypedTerm Term +wrap n = Core.termWrap . Core.wrappedTerm (asTerm n) diff --git a/src/main/haskell/Hydra/Dsl/Meta/Testing.hs b/src/main/haskell/Hydra/Dsl/Meta/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Testing.hs @@ -0,0 +1,536 @@ +{-# LANGUAGE FlexibleContexts #-} + +-- | Meta-DSL for constructing test-related terms +-- TODO: merge with Hydra.Dsl.Tests + +module Hydra.Dsl.Meta.Testing ( + module Hydra.Dsl.Testing, + module Hydra.Dsl.Meta.Testing, +) where + +import Hydra.Dsl.Testing hiding ( + tag, testCaseUniversal, testCaseWithMetadata, + testCaseWithMetadataCase, testCaseWithMetadataDescription, + testCaseWithMetadataName, testCaseWithMetadataTags, testGroup, + universalTestCase, unTag) +import Hydra.Kernel +import Hydra.Error.Core (InvalidTermError) +import Hydra.Error.Packaging (InvalidModuleError, InvalidPackageError) +import Hydra.Testing as Testing +import Hydra.Dsl.Meta.Phantoms as Phantoms hiding ((++)) +import qualified Hydra.Dsl.Meta.Lib.Eithers as Eithers +import qualified Hydra.Dsl.Meta.Lib.Lists as Lists +import qualified Hydra.Dsl.Meta.Lib.Optionals as Optionals +import qualified Hydra.Dsl.Meta.Lib.Pairs as Pairs +import qualified Hydra.Dsl.Meta.Lib.Strings as Strings +import qualified Hydra.Dsl.Meta.Terms as MetaTerms +import Hydra.Dsl.Terms (ToPrimName) +import qualified Hydra.Dsl.Meta.Types as T +import qualified Hydra.Dsl.Validation as Validation + +import qualified Data.Int as I +import qualified Data.List as L +import qualified Data.Map as M + +type Int32 = I.Int32 + + +tag_disabled = Tag "disabled" +tag_disabledForMinimalInference = Tag "disabledForMinimalInference" + +alphaConvertRef :: TypedTerm (Name -> Name -> Term -> Term) +alphaConvertRef = TypedTerm $ TermVariable $ Name "hydra.reduction.alphaConvert" + +betaReduceTypeRef :: TypedTerm (InferenceContext -> Graph -> Type -> Either Error Type) +betaReduceTypeRef = TypedTerm $ TermVariable $ Name "hydra.reduction.betaReduceType" + +-- | Refs for hydra.validate.packaging validators and their show functions. +checkConflictingModuleNamesRef :: TypedTerm (Package -> Maybe InvalidPackageError) +checkConflictingModuleNamesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkConflictingModuleNames" + +checkConflictingVariantNamesRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkConflictingVariantNamesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkConflictingVariantNames" + +checkDefinitionDocumentationRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkDefinitionDocumentationRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDefinitionDocumentation" + +checkDefinitionModuleNamesRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkDefinitionModuleNamesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDefinitionModuleNames" + +checkDefinitionNameConventionRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkDefinitionNameConventionRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDefinitionNameConvention" + +checkDefinitionOrderingRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkDefinitionOrderingRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDefinitionOrdering" + +checkDuplicateDefinitionNamesRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkDuplicateDefinitionNamesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDuplicateDefinitionNames" + +checkDuplicateModuleNamesRef :: TypedTerm (Package -> Maybe InvalidPackageError) +checkDuplicateModuleNamesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkDuplicateModuleNames" + +checkModuleNameConventionRef :: TypedTerm (Module -> Maybe InvalidModuleError) +checkModuleNameConventionRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkModuleNameConvention" + +checkPackageNameConventionRef :: TypedTerm (Package -> Maybe InvalidPackageError) +checkPackageNameConventionRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkPackageNameConvention" + +-- | Type checking test: infers the type and compares with expected. +checkTest :: String -> [Tag] -> TypedTerm Term -> TypedTerm Term -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +checkTest name tags input _outputTerm outputType = testCaseWithMetadata (Phantoms.string name) + (testCaseUniversal $ universalTestCase + (retype $ Eithers.either_ + (Phantoms.lambda "e" (Phantoms.string "<>")) + (Phantoms.lambda "result" + (showTypeRef @@ (typeSchemeToFTypeRef @@ Pairs.second (Pairs.first (Phantoms.var "result"))))) + (inferTypeOfRef @@ testContextRef @@ testGraphRef @@ input)) + (retype $ showTypeRef @@ outputType)) + nothing (Phantoms.list $ tag . unTag <$> tags) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +evalCase :: String -> TypedTerm Term -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +evalCase cname input output = evalCaseWithTags cname [] input output + +-- | Create a universal test case that evaluates a Term via reduceTerm and compares the result. +evalCaseWithTags :: String -> [Tag] -> TypedTerm Term -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +evalCaseWithTags cname tags input output = testCaseWithMetadata (Phantoms.string cname) + (testCaseUniversal $ universalTestCase + (retype $ Eithers.either_ + (Phantoms.lambda "e" (Phantoms.string "<>")) + (Phantoms.lambda "t" (showTermRef @@ Phantoms.var "t")) + (reduceTermRef @@ testContextRef @@ testGraphRef @@ true @@ input)) + (retype $ showTermRef @@ output)) + nothing (Phantoms.list $ tag . unTag <$> tags) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Create a universal test case for an expression with a show function +evalPair :: String -> TypedTerm (t -> String) -> TypedTerm t -> TypedTerm t -> TypedTerm TestCaseWithMetadata +evalPair cname showFn logicalActual logicalExpected = universalCase cname + (retype $ showFn @@ logicalActual) (retype $ showFn @@ logicalExpected) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | evalPair with tags +evalPairWithTags :: String -> [Tag] -> TypedTerm (t -> String) -> TypedTerm t -> TypedTerm t -> TypedTerm TestCaseWithMetadata +evalPairWithTags cname tags showFn logicalActual logicalExpected = testCaseWithMetadata (Phantoms.string cname) + (testCaseUniversal $ universalTestCase (retype $ showFn @@ logicalActual) (retype $ showFn @@ logicalExpected)) + nothing (Phantoms.list $ tag . unTag <$> tags) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +expectFailure :: AsTerm t Term => Int -> [Tag] -> t -> TypedTerm TestCaseWithMetadata +expectFailure i tags term = infFailureTest ("#" ++ show i) tags (asTerm term) + +expectMono :: AsTerm t Term => Int -> [Tag] -> t -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +expectMono i tags term typ = infTest ("#" ++ show i) tags (asTerm term) $ T.mono typ + +expectPoly :: AsTerm t Term => Int -> [Tag] -> t -> [String] -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +expectPoly i tags term params typ = infTest ("#" ++ show i) tags (asTerm term) $ T.poly params typ + +expectPolyConstrained :: AsTerm t Term => Int -> [Tag] -> t -> [String] -> [(String, [String])] -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +expectPolyConstrained i tags term params constraints typ = infTest ("#" ++ show i) tags (asTerm term) $ T.polyConstrained params constraints typ + +groupRef = MetaTerms.varNamePhantom . bindingName + +-- | Inference failure test: expects inference to fail. +infFailureTest :: String -> [Tag] -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +infFailureTest name tags term = testCaseWithMetadata (Phantoms.string name) + (testCaseUniversal $ universalTestCase + (retype $ Eithers.either_ + (Phantoms.lambda "e" (Phantoms.string "FAIL")) + (Phantoms.lambda "result" (Strings.cat2 (Phantoms.string "unexpected: ") + (showTypeSchemeRef @@ Pairs.second (Pairs.first (Phantoms.var "result"))))) + (inferTypeOfRef @@ testContextRef @@ testGraphRef @@ term)) + (Phantoms.string "FAIL")) + nothing (Phantoms.list $ tag . unTag <$> tags) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Inference test: infer type and compare with expected type scheme. +infTest :: String -> [Tag] -> TypedTerm Term -> TypedTerm TypeScheme -> TypedTerm TestCaseWithMetadata +infTest name tags term ts = testCaseWithMetadata (Phantoms.string name) + (testCaseUniversal $ universalTestCase + (retype $ Eithers.either_ + (Phantoms.lambda "e" (Strings.cat2 (Phantoms.string "INFERENCE ERROR: ") (Phantoms.string "failed"))) + (Phantoms.lambda "result" + (showTypeSchemeRef @@ Pairs.second (Pairs.first (Phantoms.var "result")))) + (inferTypeOfRef @@ testContextRef @@ testGraphRef @@ term)) + (retype $ showTypeSchemeRef @@ ts)) + nothing (Phantoms.list $ tag . unTag <$> tags) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +isDisabled tcase = tag_disabled `L.elem` Testing.testCaseWithMetadataTags tcase +isDisabledForMinimalInference tcase = tag_disabledForMinimalInference `L.elem` Testing.testCaseWithMetadataTags tcase + +inferTypeOfRef :: TypedTerm (InferenceContext -> Graph -> Term -> Either Error ((Term, TypeScheme), InferenceContext)) +inferTypeOfRef = TypedTerm $ TermVariable $ Name "hydra.inference.inferTypeOf" + +-- | Reference to the kernel-default core validation profile (term + type +-- rules; 'singleVariantUnion' classified as a warning, everything else +-- as an error; maxErrors=1). +kernelDefaultCoreProfileRef :: TypedTerm ValidationProfile +kernelDefaultCoreProfileRef = TypedTerm $ TermVariable $ Name "hydra.validate.core.kernelDefaultCoreProfile" + +-- | Reference to the kernel-default packaging validation profile (every +-- per-module and per-package check classified as an error; maxErrors=1). +kernelDefaultPackagingProfileRef :: TypedTerm ValidationProfile +kernelDefaultPackagingProfileRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.kernelDefaultPackagingProfile" + +-- | Reference to the kernel-strict 'kernelModule' convenience wrapper +-- (Maybe-returning, applies 'kernelDefaultPackagingProfile' internally). +-- Used by the kernelModule orchestrator tests in +-- 'Sources/Test/Validate/Packaging.hs'. +kernelModuleRef :: TypedTerm (Module -> Maybe InvalidModuleError) +kernelModuleRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.kernelModule" + +-- | Reference to the kernel-strict 'kernelPackage' convenience wrapper. +kernelPackageRef :: TypedTerm (Package -> Maybe InvalidPackageError) +kernelPackageRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.kernelPackage" + +mapTerm :: [(TypedTerm Term, TypedTerm Term)] -> TypedTerm Term +mapTerm pairs = TypedTerm $ TermInject $ Injection _Term $ Field _Term_map $ TermMap $ M.fromList [(unTypedTerm k, unTypedTerm v) | (k, v) <- pairs] + +mapTermEmpty :: TypedTerm (M.Map k v) +mapTermEmpty = TypedTerm $ TermMap M.empty + +-- | Type checking test where term doesn't change (just check the inferred type) +noChange :: String -> TypedTerm Term -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +noChange name term typ = checkTest name [] term term typ + +noTags :: TypedTerm [Tag] +noTags = Phantoms.list ([] :: [TypedTerm Tag]) + +primCase :: ToPrimName n => String -> n -> [TypedTerm Term] -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +primCase cname prim args output = primCaseWithTags cname [] prim args output + +primCaseWithTags :: ToPrimName n => String -> [Tag] -> n -> [TypedTerm Term] -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +primCaseWithTags cname tags prim args output = evalCaseWithTags cname tags input output + where + input = L.foldl (MetaTerms.@@) (MetaTerms.primitive prim) args + +reduceTermRef :: TypedTerm (InferenceContext -> Graph -> Bool -> Term -> Either Error Term) +reduceTermRef = TypedTerm $ TermVariable $ Name "hydra.reduction.reduceTerm" + +removeTypesFromTermRef :: TypedTerm (Term -> Term) +removeTypesFromTermRef = TypedTerm $ TermVariable $ Name "hydra.strip.removeTypesFromTerm" + +showInvalidModuleErrorRef :: TypedTerm (InvalidModuleError -> String) +showInvalidModuleErrorRef = TypedTerm $ TermVariable $ Name "hydra.show.error.packaging.invalidModuleError" + +showInvalidPackageErrorRef :: TypedTerm (InvalidPackageError -> String) +showInvalidPackageErrorRef = TypedTerm $ TermVariable $ Name "hydra.show.error.packaging.invalidPackageError" + +showInvalidTermErrorRef :: TypedTerm (InvalidTermError -> String) +showInvalidTermErrorRef = TypedTerm $ TermVariable $ Name "hydra.show.error.core.invalidTermError" + +showTermRef :: TypedTerm (Term -> String) +showTermRef = TypedTerm $ TermVariable $ Name "hydra.show.core.term" + +showTypeRef :: TypedTerm (Type -> String) +showTypeRef = TypedTerm $ TermVariable $ Name "hydra.show.core.type" + +showTypeSchemeRef :: TypedTerm (TypeScheme -> String) +showTypeSchemeRef = TypedTerm $ TermVariable $ Name "hydra.show.core.typeScheme" + +-- | evalPair for String-typed expressions (identity show) +stringEvalPair :: String -> TypedTerm String -> TypedTerm String -> TypedTerm TestCaseWithMetadata +stringEvalPair cname = evalPair cname (Phantoms.lambda "s" (Phantoms.var "s")) + +subgroup :: AsTerm t TestCaseWithMetadata => String -> [t] -> TypedTerm TestGroup +subgroup name cases = tgroup name Nothing [] (asTerm <$> cases) + +supergroup :: AsTerm t TestGroup => String -> [t] -> TypedTerm TestGroup +supergroup name subgroups = tgroup name Nothing (asTerm <$> subgroups) [] + +tag :: String -> TypedTerm Tag +tag = Phantoms.wrap _Tag . Phantoms.string + +testContextRef :: TypedTerm InferenceContext +testContextRef = TypedTerm $ TermVariable $ Name "hydra.test.testGraph.testContext" + +-- | References to kernel functions (avoids circular imports) +testGraphRef :: TypedTerm Graph +testGraphRef = TypedTerm $ TermVariable $ Name "hydra.test.testGraph.testGraph" + +tgroup :: String -> Maybe String -> [TypedTerm TestGroup] -> [TypedTerm TestCaseWithMetadata] -> TypedTerm TestGroup +tgroup name mdesc subgroups cases = testGroup (Phantoms.string name) (opt (Phantoms.string <$> mdesc)) (Phantoms.list subgroups) (Phantoms.list cases) + +typeSchemeToFTypeRef :: TypedTerm (TypeScheme -> Type) +typeSchemeToFTypeRef = TypedTerm $ TermVariable $ Name "hydra.scoping.typeSchemeToFType" + +universalCase :: String -> TypedTerm a -> TypedTerm b -> TypedTerm TestCaseWithMetadata +universalCase cname actual expected = testCaseWithMetadata (Phantoms.string cname) + (testCaseUniversal $ universalTestCase (retype actual) (retype expected)) + nothing noTags + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Reference to the profile-aware core term validator. Used by +-- 'validateCoreTermCase' (with 'kernelDefaultCoreProfileRef'-applied, +-- head-extracted to preserve the legacy 'Maybe E' shape) and by +-- 'validateCoreTermCaseWithProfile' (with an explicit profile). +validateCoreTermProfiledRef :: TypedTerm (ValidationProfile -> Bool -> Graph -> Term -> ValidationResult InvalidTermError) +validateCoreTermProfiledRef = TypedTerm $ TermVariable $ Name "hydra.validate.core.term" + +-- | Reference to the profile-aware packaging module validator. Used by +-- 'validatePackagingModuleCaseWithProfile' directly. +validatePackagingModuleProfiledRef :: TypedTerm (ValidationProfile -> ValidationResult InvalidModuleError -> Module -> ValidationResult InvalidModuleError) +validatePackagingModuleProfiledRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.module" + +-- | Reference to the profile-aware packaging package validator. Returns a +-- 'ValidationResult InvalidPackageError'; used by +-- 'validatePackagingPackageCaseWithProfile'. +validatePackagingPackageProfiledRef :: TypedTerm (ValidationProfile -> ValidationResult InvalidPackageError -> Package -> ValidationResult InvalidPackageError) +validatePackagingPackageProfiledRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.package" + +---------------------------------------- + +-- | Convenience function for creating alpha conversion test cases +alphaCase :: String -> TypedTerm Term -> TypedTerm Name -> TypedTerm Name -> TypedTerm Term -> TypedTerm TestCaseWithMetadata +alphaCase cname term oldVar newVar result = universalCase cname + (retype $ showTermRef @@ (alphaConvertRef @@ oldVar @@ newVar @@ term)) + (retype $ showTermRef @@ result) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +encodedTestGroupToBinding :: ModuleName -> String -> TypedTerm TestGroup -> Binding +encodedTestGroupToBinding ns lname group = Binding name (unTypedTerm group) + $ Just $ TypeScheme [] typ Nothing + where + name = unqualifyName $ QualifiedName (Just ns) lname + typ = TypeVariable _TestGroup + +-- | Render a 'ValidationResult InvalidModuleError' as a string of the form +-- "errors=[s1;s2] warnings=[w1]". Counterpart of 'showValidationResultTerm' +-- for module-level findings. +showValidationResultModule :: TypedTerm (ValidationResult InvalidModuleError) -> TypedTerm String +showValidationResultModule vr = retype $ + Strings.cat2 + (Strings.cat2 (Phantoms.string "errors=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "e" $ showInvalidModuleErrorRef @@ Phantoms.var "e") + (Validation.validationResultErrors vr)) + (Phantoms.string "]")) + (Strings.cat2 (Phantoms.string " warnings=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "w" $ showInvalidModuleErrorRef @@ Phantoms.var "w") + (Validation.validationResultWarnings vr)) + (Phantoms.string "]")) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Render a 'ValidationResult InvalidPackageError' as a string. Package-level +-- counterpart of 'showValidationResultTerm'. +showValidationResultPackage :: TypedTerm (ValidationResult InvalidPackageError) -> TypedTerm String +showValidationResultPackage vr = retype $ + Strings.cat2 + (Strings.cat2 (Phantoms.string "errors=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "e" $ showInvalidPackageErrorRef @@ Phantoms.var "e") + (Validation.validationResultErrors vr)) + (Phantoms.string "]")) + (Strings.cat2 (Phantoms.string " warnings=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "w" $ showInvalidPackageErrorRef @@ Phantoms.var "w") + (Validation.validationResultWarnings vr)) + (Phantoms.string "]")) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Profile-aware variant of 'validatePackagingModuleCase'. Calls +-- 'hydra.validate.packaging.module'' (the new orchestrator) starting from +-- an empty 'ValidationResult' and compares the full result shape against +-- the expected. +validatePackagingModuleCaseWithProfile + :: String + -> TypedTerm ValidationProfile + -> TypedTerm Module + -> TypedTerm (ValidationResult InvalidModuleError) + -> TypedTerm TestCaseWithMetadata +validatePackagingModuleCaseWithProfile cname profile input expected = universalCase cname + (showValidationResultModule + (validatePackagingModuleProfiledRef @@ profile @@ emptyResultModule @@ input)) + (showValidationResultModule expected) + where + emptyResultModule :: TypedTerm (ValidationResult InvalidModuleError) + emptyResultModule = Validation.validationResult + (Phantoms.list ([] :: [TypedTerm InvalidModuleError])) + (Phantoms.list ([] :: [TypedTerm InvalidModuleError])) + +-- | Profile-aware variant of 'validatePackagingPackageCase'. +validatePackagingPackageCaseWithProfile + :: String + -> TypedTerm ValidationProfile + -> TypedTerm Package + -> TypedTerm (ValidationResult InvalidPackageError) + -> TypedTerm TestCaseWithMetadata +validatePackagingPackageCaseWithProfile cname profile input expected = universalCase cname + (showValidationResultPackage + (validatePackagingPackageProfiledRef @@ profile @@ emptyResultPackage @@ input)) + (showValidationResultPackage expected) + where + emptyResultPackage :: TypedTerm (ValidationResult InvalidPackageError) + emptyResultPackage = Validation.validationResult + (Phantoms.list ([] :: [TypedTerm InvalidPackageError])) + (Phantoms.list ([] :: [TypedTerm InvalidPackageError])) + +-- | Render a 'ValidationResult InvalidTermError' as a string of the form +-- "errors=[s1;s2] warnings=[w1]". Used to compare actual vs expected +-- 'ValidationResult' values in profile-aware test cases. +showValidationResultTerm :: TypedTerm (ValidationResult InvalidTermError) -> TypedTerm String +showValidationResultTerm vr = retype $ + Strings.cat2 + (Strings.cat2 (Phantoms.string "errors=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "e" $ showInvalidTermErrorRef @@ Phantoms.var "e") + (Validation.validationResultErrors vr)) + (Phantoms.string "]")) + (Strings.cat2 (Phantoms.string " warnings=[") $ + Strings.cat2 (Strings.intercalate (Phantoms.string ";") $ + Lists.map (Phantoms.lambda "w" $ showInvalidTermErrorRef @@ Phantoms.var "w") + (Validation.validationResultWarnings vr)) + (Phantoms.string "]")) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Profile-aware variant of 'validateCoreTermCase'. Compares the full +-- 'ValidationResult' shape — both errors and warnings — against the +-- expected, allowing the caller to specify any profile (not just the +-- kernel default). Use for tests that exercise multi-error +-- accumulation, warning vs error classification, or rule disabling. +validateCoreTermCaseWithProfile + :: String + -> TypedTerm ValidationProfile + -> TypedTerm Bool + -> TypedTerm Term + -> TypedTerm (ValidationResult InvalidTermError) + -> TypedTerm TestCaseWithMetadata +validateCoreTermCaseWithProfile cname profile typed input expected = universalCase cname + (showValidationResultTerm + (validateCoreTermProfiledRef @@ profile @@ typed @@ testGraphRef @@ input)) + (showValidationResultTerm expected) + +testCaseUniversal :: TypedTerm UniversalTestCase -> TypedTerm TestCase +testCaseUniversal = inject _TestCase _TestCase_universal + +testCaseWithMetadata :: TypedTerm String -> TypedTerm TestCase -> TypedTerm (Maybe String) -> TypedTerm [Tag] -> TypedTerm TestCaseWithMetadata +testCaseWithMetadata name tcase description tags = Phantoms.record _TestCaseWithMetadata [ + _TestCaseWithMetadata_name>>: name, + _TestCaseWithMetadata_case>>: tcase, + _TestCaseWithMetadata_description>>: description, + _TestCaseWithMetadata_tags>>: tags] + +testCaseWithMetadataCase :: TypedTerm (TestCaseWithMetadata -> TestCase) +testCaseWithMetadataCase = Phantoms.project _TestCaseWithMetadata _TestCaseWithMetadata_case + +testCaseWithMetadataDescription :: TypedTerm (TestCaseWithMetadata -> Maybe String) +testCaseWithMetadataDescription = Phantoms.project _TestCaseWithMetadata _TestCaseWithMetadata_description + +testCaseWithMetadataName :: TypedTerm (TestCaseWithMetadata -> String) +testCaseWithMetadataName = Phantoms.project _TestCaseWithMetadata _TestCaseWithMetadata_name + +testCaseWithMetadataTags :: TypedTerm (TestCaseWithMetadata -> [Tag]) +testCaseWithMetadataTags = Phantoms.project _TestCaseWithMetadata _TestCaseWithMetadata_tags + +testGroup :: TypedTerm String -> TypedTerm (Maybe String) -> TypedTerm [TestGroup] -> TypedTerm [TestCaseWithMetadata] -> TypedTerm TestGroup +testGroup name description subgroups cases = Phantoms.record _TestGroup [ + _TestGroup_name>>: name, + _TestGroup_description>>: description, + _TestGroup_subgroups>>: subgroups, + _TestGroup_cases>>: cases] + +-- | Convenience function for creating type reduction test cases +typeRedCase :: String -> TypedTerm Type -> TypedTerm Type -> TypedTerm TestCaseWithMetadata +typeRedCase cname input output = universalCase cname + (retype $ Eithers.either_ + (Phantoms.lambda "e" (Phantoms.string "<>")) + (Phantoms.lambda "t" (showTypeRef @@ Phantoms.var "t")) + (betaReduceTypeRef @@ testContextRef @@ testGraphRef @@ input)) + (retype $ showTypeRef @@ output) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Build a 'UniversalTestCase' from two string-producing expressions. +-- Each expression is wrapped in a unit-lambda so its evaluation is deferred +-- until the runner forces the thunk inside its per-test timing bracket. See +-- issue #311: without thunking, eagerly-evaluated hosts (Scala, the four +-- complete Lisps) compute 'actual'/'expected' at test-data load time, before +-- any timer starts, and report zero elapsed time. +universalTestCase :: TypedTerm String -> TypedTerm String -> TypedTerm UniversalTestCase +universalTestCase actual expected = Phantoms.record _UniversalTestCase [ + _UniversalTestCase_actual Phantoms.>>: thunk actual, + _UniversalTestCase_expected Phantoms.>>: thunk expected] + where + thunk :: TypedTerm String -> TypedTerm (() -> String) + thunk body = Phantoms.lambda "_" body + +-- | Convenience function for creating validation test cases. Drives the +-- profile-aware 'hydra.validate.core.term' with the kernel-default core +-- profile and head-extracts the resulting errors list — preserving the +-- legacy 'Maybe InvalidTermError' shape that existing test data uses. +-- Tests that need to assert multi-error accumulation, warning +-- classification, or rule disabling should use +-- 'validateCoreTermCaseWithProfile' instead. +validateCoreTermCase :: String -> TypedTerm Bool -> TypedTerm Term -> TypedTerm (Maybe InvalidTermError) -> TypedTerm TestCaseWithMetadata +validateCoreTermCase cname typed input expected = universalCase cname + (retype $ Optionals.cases + (Lists.maybeHead $ Validation.validationResultErrors $ + validateCoreTermProfiledRef @@ kernelDefaultCoreProfileRef @@ typed @@ testGraphRef @@ input) + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidTermErrorRef @@ Phantoms.var "e"))) + (retype $ Optionals.cases + expected + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidTermErrorRef @@ Phantoms.var "e"))) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Convenience function for creating module-validation test cases. +-- Applies a packaging-level Module validator to an input module and compares +-- the result against the expected Maybe InvalidModuleError. +validatePackagingModuleCase :: String -> TypedTerm (Module -> Maybe InvalidModuleError) -> TypedTerm Module -> TypedTerm (Maybe InvalidModuleError) -> TypedTerm TestCaseWithMetadata +validatePackagingModuleCase cname validator input expected = universalCase cname + (retype $ Optionals.cases + (validator @@ input) + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidModuleErrorRef @@ Phantoms.var "e"))) + (retype $ Optionals.cases + expected + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidModuleErrorRef @@ Phantoms.var "e"))) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t + +-- | Convenience function for creating package-validation test cases. +-- Applies a packaging-level Package validator to an input package and compares +-- the result against the expected Maybe InvalidPackageError. +validatePackagingPackageCase :: String -> TypedTerm (Package -> Maybe InvalidPackageError) -> TypedTerm Package -> TypedTerm (Maybe InvalidPackageError) -> TypedTerm TestCaseWithMetadata +validatePackagingPackageCase cname validator input expected = universalCase cname + (retype $ Optionals.cases + (validator @@ input) + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidPackageErrorRef @@ Phantoms.var "e"))) + (retype $ Optionals.cases + expected + (Phantoms.string "valid") + (Phantoms.lambda "e" (showInvalidPackageErrorRef @@ Phantoms.var "e"))) + where + retype :: TypedTerm x -> TypedTerm String + retype (TypedTerm t) = TypedTerm t diff --git a/src/main/haskell/Hydra/Dsl/Meta/Types.hs b/src/main/haskell/Hydra/Dsl/Meta/Types.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Types.hs @@ -0,0 +1,298 @@ +-- | A domain-specific language for constructing term-encoded Hydra types in Haskell; +-- these functions enable you to build terms (programs) which build types. + +{-# LANGUAGE FlexibleContexts #-} + +module Hydra.Dsl.Meta.Types ( + module Hydra.Dsl.Meta.Base, + module Hydra.Dsl.Meta.Types, +) where + +import Hydra.Kernel +import Hydra.Dsl.AsTerm +import qualified Hydra.Dsl.Meta.Phantoms as Phantoms +import qualified Hydra.Dsl.Meta.Lib.Maps as Maps +import Hydra.Dsl.Meta.Core as Core hiding (name, unName) +import Hydra.Dsl.Meta.Base + +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Maybe as Y +import qualified Data.Set as S +import Prelude hiding (either, map, maybe, product, sum) + + +-- Operators + +-- | Type application operator +-- Example: typeConstructor @@ typeArg +(@@) :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +(@@) = apply + +-- | Function type constructor operator +-- Example: int32 --> string +(-->) :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +(-->) = function + + +-- | Attach an annotation map to a term-encoded type, wrapping the map as a +-- TermMap annotation per Hydra's convention (#386). Each Name key is lifted +-- to a TermVariable. +-- Example: annot annotationMap myType +annot :: TypedTerm (M.Map Name Term) -> TypedTerm Type -> TypedTerm Type +annot ann typ = typeAnnotated $ annotatedType typ + (Core.termMap (Maps.mapKeys (Phantoms.lambda "n" (Core.termVariable (Phantoms.var "n"))) ann)) + +-- | Apply a term-encoded type to a type argument +-- Example: apply (var "Maybe") int32 +apply :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +apply l r = typeApplication $ applicationType l r + +applys :: TypedTerm Type -> [TypedTerm Type] -> TypedTerm Type +applys t ts = L.foldl apply t ts + +-- | Create a term-encoded arbitrary-precision integer type +-- Example: bigint +bigint :: TypedTerm Type +bigint = typeLiteral $ literalTypeInteger integerTypeBigint + +-- | Create a term-encoded binary type +-- Example: binary +binary :: TypedTerm Type +binary = typeLiteral literalTypeBinary + +-- | Create a term-encoded boolean type +-- Example: boolean +boolean :: TypedTerm Type +boolean = typeLiteral literalTypeBoolean + +-- | Create a term-encoded arbitrary-precision decimal type +-- Example: decimal +decimal :: TypedTerm Type +decimal = typeLiteral literalTypeDecimal + +-- | Create a term-encoded either type +-- Example: either_ string int32 +either_ :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +either_ l r = typeEither $ eitherType l r + +-- | Create a term-encoded enum type with the given variant names (conventionally in camelCase) +-- Example: enum (name "Color") ["red", "green", "blue"] +-- Accepts TypedTerm Name or TypedBinding Name (via AsTerm) +enum :: AsTerm t Name => t -> [String] -> TypedTerm Type +enum tname names = union tname $ (\n -> (name n, unit)) <$> names + +-- | Create a term-encoded field with the given name and type +-- Example: field "age" int32 +field :: String -> TypedTerm Type -> TypedTerm FieldType +field s = fieldType (name s) + +-- | Create a term-encoded FloatType representation +-- Example: float FloatTypeFloat64 +float :: FloatType -> TypedTerm FloatType +float t = Phantoms.injectUnit _FloatType $ case t of + FloatTypeFloat32 -> _FloatType_float32 + FloatTypeFloat64 -> _FloatType_float64 + +-- | Create a term-encoded 32-bit floating point type +-- Example: float32 +float32 :: TypedTerm Type +float32 = typeLiteral $ literalTypeFloat $ float FloatTypeFloat32 + +-- | Create a term-encoded 64-bit floating point type +-- Example: float64 +float64 :: TypedTerm Type +float64 = typeLiteral $ literalTypeFloat $ float FloatTypeFloat64 + +-- | Create a term-encoded universal quantification (polymorphic type) +-- Example: forAll "a" (var "a" --> var "a") +forAll :: String -> TypedTerm Type -> TypedTerm Type +forAll var body = typeForall $ forallType (name var) body + +forAlls :: [String] -> TypedTerm Type -> TypedTerm Type +forAlls vs body = L.foldr forAll body vs + +-- | Create a term-encoded function type +-- Example: function int32 string +function :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +function dom cod = typeFunction $ functionType dom cod + +-- | Create a term-encoded multi-parameter function type +-- Example: functionMany [int32, string, boolean] +functionMany :: [TypedTerm Type] -> TypedTerm Type +functionMany types = case types of + [t] -> t + t:ts -> function t $ functionMany ts + +-- | Create a term-encoded 16-bit signed integer type +-- Example: int16 +int16 :: TypedTerm Type +int16 = typeLiteral $ literalTypeInteger integerTypeInt16 + +-- | Create a term-encoded 32-bit signed integer type +-- Example: int32 +int32 :: TypedTerm Type +int32 = typeLiteral $ literalTypeInteger integerTypeInt32 + +-- | Create a term-encoded 64-bit signed integer type +-- Example: int64 +int64 :: TypedTerm Type +int64 = typeLiteral $ literalTypeInteger integerTypeInt64 + +-- | Create a term-encoded 8-bit signed integer type +-- Example: int8 +int8 :: TypedTerm Type +int8 = typeLiteral $ literalTypeInteger integerTypeInt8 + +-- | Create a term-encoded IntegerType representation +-- Example: integer IntegerTypeInt32 +integer :: IntegerType -> TypedTerm IntegerType +integer t = Phantoms.injectUnit _IntegerType $ case t of + IntegerTypeBigint -> _IntegerType_bigint + IntegerTypeInt8 -> _IntegerType_int8 + IntegerTypeInt16 -> _IntegerType_int16 + IntegerTypeInt32 -> _IntegerType_int32 + IntegerTypeInt64 -> _IntegerType_int64 + IntegerTypeUint8 -> _IntegerType_uint8 + IntegerTypeUint16 -> _IntegerType_uint16 + IntegerTypeUint32 -> _IntegerType_uint32 + IntegerTypeUint64 -> _IntegerType_uint64 + +-- | Create a term-encoded list type +-- Example: list string +list :: TypedTerm Type -> TypedTerm Type +list = typeList + +-- | Create a term-encoded literal type from a LiteralType value +-- Example: literal (literalTypeInteger integerTypeInt32) +literal :: TypedTerm LiteralType -> TypedTerm Type +literal = typeLiteral + +-- | Create a term-encoded map/dictionary type +-- Example: map string int32 +map :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +map k v = typeMap $ mapType k v + +-- | Create a term-encoded monomorphic type scheme +-- Example: mono int32 +mono :: TypedTerm Type -> TypedTerm TypeScheme +mono t = Phantoms.record _TypeScheme [ + Phantoms.field _TypeScheme_variables $ Phantoms.list ([] :: [TypedTerm Name]), + Phantoms.field _TypeScheme_body t, + Phantoms.field _TypeScheme_constraints Phantoms.nothing] + +-- | Term-encoded non-negative 32-bit integer type +-- Currently an alias for int32; intended for semantic annotation +-- In future versions, this may include validation constraints +-- Example: nonNegativeInt32 +nonNegativeInt32 :: TypedTerm Type +nonNegativeInt32 = Hydra.Dsl.Meta.Types.int32 + +-- | Create a term-encoded optional (nullable) type +-- Example: optional string +optional :: TypedTerm Type -> TypedTerm Type +optional = typeOptional + +-- | Create a term-encoded pair type +-- Example: pair string int32 +pair :: TypedTerm Type -> TypedTerm Type -> TypedTerm Type +pair first second = Core.typePair $ Core.pairType first second + +-- | Create a term-encoded polymorphic type scheme +-- Example: poly ["a", "b"] (var "a" --> var "b") +poly :: [String] -> TypedTerm Type -> TypedTerm TypeScheme +poly params t = Phantoms.record _TypeScheme [ + Phantoms.field _TypeScheme_variables (Phantoms.list (name <$> params)), + Phantoms.field _TypeScheme_body t, + Phantoms.field _TypeScheme_constraints Phantoms.nothing] + +-- | Create a term-encoded polymorphic type scheme with class constraints +-- Example: polyConstrained ["k", "v"] [("k", ["ordering"])] (map (var "k") (var "v")) +polyConstrained :: [String] -> [(String, [String])] -> TypedTerm Type -> TypedTerm TypeScheme +polyConstrained params constraints t = Phantoms.record _TypeScheme [ + Phantoms.field _TypeScheme_variables (Phantoms.list (name <$> params)), + Phantoms.field _TypeScheme_body t, + Phantoms.field _TypeScheme_constraints constraintsTerm] + where + constraintsTerm = Phantoms.just $ Phantoms.map $ M.fromList + [(name v, Core.typeVariableConstraints (Phantoms.list (Core.typeClassConstraintSimple . name <$> classes))) + | (v, classes) <- constraints] + +-- | Create a term-encoded product type (tuple) with multiple components using nested pairs +-- Example: product [string, int32, boolean] +product :: [TypedTerm Type] -> TypedTerm Type +product [] = unit +product [a] = a +product [a, b] = pair a b +product (a:rest) = pair a (product rest) + +-- | Create a term-encoded record type with named fields +-- Example: record (name "Person") ["name">: string, "age">: int32] +-- Note: the name parameter is now ignored; record types no longer carry a type name +record :: AsTerm t Name => t -> [(TypedTerm Name, TypedTerm Type)] -> TypedTerm Type +record _n pairs = typeRecord $ Phantoms.list (toField <$> pairs) + where + toField (fn, t) = fieldType fn t + +-- | Create a term-encoded set type +-- Example: set string +set :: TypedTerm Type -> TypedTerm Type +set = typeSet + +-- | Create a term-encoded string type +-- Example: string +string :: TypedTerm Type +string = typeLiteral literalTypeString + +-- | Create a term-encoded 16-bit unsigned integer type +-- Example: uint16 +uint16 :: TypedTerm Type +uint16 = typeLiteral $ literalTypeInteger integerTypeUint16 + +-- | Create a term-encoded 32-bit unsigned integer type +-- Example: uint32 +uint32 :: TypedTerm Type +uint32 = typeLiteral $ literalTypeInteger integerTypeUint32 + +-- | Create a term-encoded 64-bit unsigned integer type +-- Example: uint64 +uint64 :: TypedTerm Type +uint64 = typeLiteral $ literalTypeInteger integerTypeUint64 + +-- | Create a term-encoded 8-bit unsigned integer type +-- Example: uint8 +uint8 :: TypedTerm Type +uint8 = typeLiteral $ literalTypeInteger integerTypeUint8 + +-- | Create a term-encoded union type with named variants +-- Example: union (name "Result") ["success">: int32, "error">: string] +-- Note: the name parameter is now ignored; union types no longer carry a type name +union :: AsTerm t Name => t -> [(TypedTerm Name, TypedTerm Type)] -> TypedTerm Type +union _n pairs = typeUnion $ Phantoms.list (toField <$> pairs) + where + toField (fn, ft) = fieldType fn ft + +-- | Term-encoded unit type (empty record type) +-- Example: unit +unit :: TypedTerm Type +unit = typeUnit + +-- | Create a term-encoded type variable (alias for 'variable') +-- Example: var "a" +var :: String -> TypedTerm Type +var = variable + +-- | Create a term-encoded type variable +-- Example: variable "a" +variable :: String -> TypedTerm Type +variable = typeVariable . name + +-- | Term-encoded void type (uninhabited / bottom type) +-- Example: void +void :: TypedTerm Type +void = typeVoid + +-- | Create a term-encoded wrapped type (newtype) +-- Note: the name parameter is now ignored; wrapped types no longer carry a type name +wrap :: AsTerm t Name => t -> TypedTerm Type -> TypedTerm Type +wrap _n t = typeWrap t diff --git a/src/main/haskell/Hydra/Dsl/Meta/Variants.hs b/src/main/haskell/Hydra/Dsl/Meta/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Variants.hs @@ -0,0 +1,68 @@ +-- | Haskell-specific convenience layer over the generated Hydra.Dsl.Variants module. +-- Adds Haskell enum -> TypedTerm converter functions. + +module Hydra.Dsl.Meta.Variants ( + module Hydra.Dsl.Variants, + module Hydra.Dsl.Meta.Variants, +) where + +import Hydra.Kernel +import Hydra.Dsl.Meta.Phantoms +import Hydra.Dsl.Variants + + +-- | Convert a Haskell LiteralVariant to a TypedTerm +literalVariant :: LiteralVariant -> TypedTerm LiteralVariant +literalVariant v = injectUnit _LiteralVariant $ case v of + LiteralVariantBinary -> _LiteralVariant_binary + LiteralVariantBoolean -> _LiteralVariant_boolean + LiteralVariantDecimal -> _LiteralVariant_decimal + LiteralVariantFloat -> _LiteralVariant_float + LiteralVariantInteger -> _LiteralVariant_integer + LiteralVariantString -> _LiteralVariant_string + +-- | Convert a Haskell TermVariant to a TypedTerm +termVariant :: TermVariant -> TypedTerm TermVariant +termVariant v = injectUnit _TermVariant $ case v of + TermVariantAnnotated -> _TermVariant_annotated + TermVariantApplication -> _TermVariant_application + TermVariantCases -> _TermVariant_cases + TermVariantEither -> _TermVariant_either + TermVariantLambda -> _TermVariant_lambda + TermVariantLet -> _TermVariant_let + TermVariantList -> _TermVariant_list + TermVariantLiteral -> _TermVariant_literal + TermVariantMap -> _TermVariant_map + TermVariantOptional -> _TermVariant_optional + TermVariantPair -> _TermVariant_pair + TermVariantProject -> _TermVariant_project + TermVariantRecord -> _TermVariant_record + TermVariantSet -> _TermVariant_set + TermVariantTypeLambda -> _TermVariant_typeLambda + TermVariantTypeApplication -> _TermVariant_typeApplication + TermVariantInject -> _TermVariant_inject + TermVariantUnit -> _TermVariant_unit + TermVariantUnwrap -> _TermVariant_unwrap + TermVariantVariable -> _TermVariant_variable + TermVariantWrap -> _TermVariant_wrap + +-- | Convert a Haskell TypeVariant to a TypedTerm +typeVariant :: TypeVariant -> TypedTerm TypeVariant +typeVariant v = injectUnit _TypeVariant $ case v of + TypeVariantAnnotated -> _TypeVariant_annotated + TypeVariantApplication -> _TypeVariant_application + TypeVariantEither -> _TypeVariant_either + TypeVariantFunction -> _TypeVariant_function + TypeVariantForall -> _TypeVariant_forall + TypeVariantList -> _TypeVariant_list + TypeVariantLiteral -> _TypeVariant_literal + TypeVariantMap -> _TypeVariant_map + TypeVariantOptional -> _TypeVariant_optional + TypeVariantPair -> _TypeVariant_pair + TypeVariantRecord -> _TypeVariant_record + TypeVariantSet -> _TypeVariant_set + TypeVariantUnion -> _TypeVariant_union + TypeVariantUnit -> _TypeVariant_unit + TypeVariantVariable -> _TypeVariant_variable + TypeVariantVoid -> _TypeVariant_void + TypeVariantWrap -> _TypeVariant_wrap diff --git a/src/main/haskell/Hydra/Dsl/Prims.hs b/src/main/haskell/Hydra/Dsl/Prims.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Prims.hs @@ -0,0 +1,435 @@ +{-# LANGUAGE FlexibleInstances #-} -- for IsString with nontrivial parameters + +-- | A DSL for constructing primitive function definitions +module Hydra.Dsl.Prims where + +import Hydra.Core +import Hydra.Graph +import Hydra.Packaging +import Hydra.Scoping (typeSchemeToTermSignature) +import Hydra.Util +import qualified Hydra.Encode.Core as EncodeCore +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.Typing as Typing +import qualified Hydra.Errors as Error +import qualified Hydra.Extract.Util as ExtractUtil +import qualified Hydra.Dsl.Terms as Terms +import Hydra.Dsl.Terms (ToPrimName(..)) +import qualified Hydra.Dsl.Types as Types +import qualified Hydra.Show.Core as ShowCore + +import Data.Int +import qualified Data.ByteString as B +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Scientific as Sci +import qualified Data.Set as S +import qualified Data.Maybe as Y +import Hydra.Strip (removeTermAnnotations) +import Hydra.Lexical (emptyInferenceContext) +import Data.String(IsString(..)) +import Data.Either (Either) + +-- | Placeholder InferenceContext for the TermCoder encode/decode machinery used inside the prim* +-- wrappers. Since #446, a Primitive's implementation carrier no longer threads the InferenceContext: +-- coders use it only for error context (otherErr ignores it) and decode (which doesn't consult it), +-- so an empty cx is sufficient and correct. The Graph, by contrast, is still threaded through the +-- carrier and passed to the coders, because the higher-order primitives that evaluate a function +-- argument (via functionWithReduce) need the live graph to resolve primitive names. +primCx :: Typing.InferenceContext +primCx = emptyInferenceContext + +bigint :: TermCoder Integer +bigint = TermCoder Types.bigint encode decode + where + encode _cx g = ExtractCore.bigint g + decode _cx = Right . Terms.bigint + +binary :: TermCoder B.ByteString +binary = TermCoder Types.binary encode decode + where + encode _cx g = ExtractCore.binary g + decode _cx = Right . Terms.binary + +boolean :: TermCoder Bool +boolean = TermCoder Types.boolean encode decode + where + encode _cx g = ExtractCore.boolean g + decode _cx = Right . Terms.boolean + +-- | Build a TypeScheme from type variables and a type +-- Uses polyConstrained if there are any constraints, otherwise poly +buildTypeScheme :: [TypeVar] -> Type -> TypeScheme +buildTypeScheme vars typ = + let constraints = typeVarsToConstraints vars + in if L.null constraints + then Types.poly (typeVarNames vars) typ + else Types.polyConstrained (fmap (\tv -> (typeVarName tv, typeVarClasses tv)) vars) typ + +instance IsString (TermCoder Term) where fromString = variable + +comparison :: TermCoder Comparison +comparison = TermCoder (TypeVariable _Comparison) encode decode + where + encode _cx g = ExtractUtil.comparison _cx g + decode _cx = Right . Terms.comparison + +decimal :: TermCoder Sci.Scientific +decimal = TermCoder Types.decimal encode decode + where + encode _cx g = ExtractCore.decimal g + decode _cx = Right . Terms.decimal + +-- | The qualified name of a primitive, read from its PrimitiveDefinition. A short +-- contextual alias for 'primitiveDefinitionName', used by DSL source modules to +-- reference primitive names via the generated Hydra.Lib.* definition modules (e.g. +-- @primName Math.acos@) instead of hand-maintained name constants. +primName :: PrimitiveDefinition -> Name +primName = primitiveDefinitionName + +-- 'ToPrimName' (used by prim0/prim1/prim2/prim3 below to accept a generated PrimitiveDefinition +-- directly, e.g. @prim2 DefMath.add ...@) is defined in 'Hydra.Dsl.Terms' to avoid an import cycle +-- and re-exported here for the registry/DSL modules. + +-- | Synthesize a minimal PrimitiveDefinition from a name and TypeScheme. +-- Used by the prim0/prim1/prim2/prim3 helpers to bridge the kernel-shape change +-- before the per-primitive metadata audit (description, isPure/isTotal exceptions, +-- defaultImplementation) is performed. +defaultPrimitiveDefinition :: Name -> TypeScheme -> PrimitiveDefinition +defaultPrimitiveDefinition name typ = PrimitiveDefinition { + primitiveDefinitionName = name, + primitiveDefinitionSignature = typeSchemeToTermSignature typ, + primitiveDefinitionMetadata = Nothing, + primitiveDefinitionIsPure = True, + primitiveDefinitionIsTotal = True, + primitiveDefinitionDefaultImplementation = Nothing} + +-- | Mark the value parameters at the given (0-based) positions of a primitive's +-- signature as lazy. Used at the prim*-based registration sites in +-- Hydra.Dsl.Libraries to record which arguments coders must thunk in hosts +-- that distinguish strict from lazy evaluation (issue #391). The kernel DSL +-- sources (Hydra.Sources.Kernel.Lib.*) carry the same flags via lazySig; this +-- keeps the Haskell-host bootstrapGraph in agreement with the JSON. +lazyArgs :: [Int] -> Primitive -> Primitive +lazyArgs idxs p = p { primitiveDefinition = markLazyDef (primitiveDefinition p) } + where + markLazyDef d = d { + primitiveDefinitionSignature = markLazySig (primitiveDefinitionSignature d) } + markLazySig s = s { + Typing.termSignatureParameters = + zipWith markParam [0..] (Typing.termSignatureParameters s) } + markParam i param = + if i `elem` idxs then param { Typing.parameterIsLazy = True } else param + +either_ :: TermCoder x -> TermCoder y -> TermCoder (Prelude.Either x y) +either_ xCoder yCoder = TermCoder (Types.either_ (termCoderType xCoder) (termCoderType yCoder)) encode decode + where + encode cx g term = case term of + TermEither (Prelude.Left l) -> Prelude.Left <$> termCoderEncode xCoder cx g l + TermEither (Prelude.Right r) -> Prelude.Right <$> termCoderEncode yCoder cx g r + _ -> Left $ otherErr cx $ "expected either term, got: " ++ show term + decode cx ev = case ev of + Prelude.Left x -> do + xTerm <- termCoderDecode xCoder cx x + return $ Terms.left xTerm + Prelude.Right y -> do + yTerm <- termCoderDecode yCoder cx y + return $ Terms.right yTerm + +float32 :: TermCoder Float +float32 = TermCoder Types.float32 encode decode + where + encode _cx g = ExtractCore.float32 g + decode _cx = Right . Terms.float32 + +float64 :: TermCoder Double +float64 = TermCoder Types.float64 encode decode + where + encode _cx g = ExtractCore.float64 g + decode _cx = Right . Terms.float64 + +floatType :: TermCoder FloatType +floatType = TermCoder (TypeVariable _FloatType) encode decode + where + encode _cx g term = case DecodeCore.floatType g term of + Left err -> Left $ Error.ErrorDecoding err + Right v -> Right v + decode _cx = Right . EncodeCore.floatType + +floatValue :: TermCoder FloatValue +floatValue = TermCoder (TypeVariable _FloatValue) encode decode + where + encode _cx g = ExtractCore.floatValue g + decode _cx = Right . Terms.float + +function :: TermCoder x -> TermCoder y -> TermCoder (x -> y) +function dom cod = TermCoder (Types.function (termCoderType dom) (termCoderType cod)) encode decode + where + encode cx _g term = Left $ otherErr cx $ "cannot encode term to a function: " ++ ShowCore.term term + decode cx _val = Left $ otherErr cx "cannot decode functions to terms" + +-- | A graph-free TermCoder for function types (issue #446). Instead of calling the reducer to +-- evaluate the application eagerly, the bridged native function builds an UNREDUCED application +-- term @apply funTerm argTerm@ and lets the interpreter's outer @reduce@ fold it. This is the +-- replacement for @functionWithReduce@ for the higher-order primitives whose result shape is +-- fixed by the (already-reduced) data argument's spine — i.e. those that never need to inspect +-- the reduced value of a per-element application mid-computation. It threads no InferenceContext +-- or Graph, which is what lets the @Primitive.implementation@ carrier drop those parameters. +-- +-- Only the encode side is defined (functions are never decoded back to terms), matching +-- @functionWithReduce@. dom/cod are the term coders for the argument and result; for the +-- higher-order primitives this is always the identity @term@/@variable@ coder, so a bridged +-- @Term -> Term@ is @\\argTerm -> TermApplication (Application funTerm argTerm)@. +functionDeferred :: TermCoder x -> TermCoder y -> TermCoder (x -> y) +functionDeferred dom cod = TermCoder (Types.function (termCoderType dom) (termCoderType cod)) encode decode + where + encode cx g funTerm = Right $ \x -> + let argTerm = case termCoderDecode dom cx x of + Left _ -> error "functionDeferred: failed to decode argument" + Right t -> t + resultTerm = TermApplication (Application funTerm argTerm) + in case termCoderEncode cod cx g resultTerm of + Left _ -> error "functionDeferred: failed to encode result" + Right v -> v + decode cx _val = Left $ otherErr cx "cannot decode functions to terms" + +-- | A TermCoder for function types, using a reducer to bridge term-level functions to native functions. +-- The reducer is called to evaluate function application at the term level. +-- Failures in reduction or encoding/decoding will result in a runtime error. +functionWithReduce :: (Typing.InferenceContext -> Graph -> Term -> Either Error.Error Term) -> TermCoder x -> TermCoder y -> TermCoder (x -> y) +functionWithReduce reduce dom cod = TermCoder (Types.function (termCoderType dom) (termCoderType cod)) encode decode + where + encode cx g funTerm = Right $ \x -> + let argTerm = case termCoderDecode dom cx x of + Left _ -> error "functionWithReduce: failed to encode argument" + Right t -> t + resultTerm = case reduce cx g (TermApplication (Application funTerm argTerm)) of + Left _ -> error "functionWithReduce: failed to reduce application" + Right t -> t + in case termCoderEncode cod cx g resultTerm of + Left _ -> error "functionWithReduce: failed to decode result" + Right v -> v + decode cx _val = Left $ otherErr cx "cannot decode functions to terms" + +int16 :: TermCoder Int16 +int16 = TermCoder Types.int16 encode decode + where + encode _cx g = ExtractCore.int16 g + decode _cx = Right . Terms.int16 + +int32 :: TermCoder Int +int32 = TermCoder Types.int32 encode decode + where + encode _cx g = ExtractCore.int32 g + decode _cx = Right . Terms.int32 + +int64 :: TermCoder Int64 +int64 = TermCoder Types.int64 encode decode + where + encode _cx g = ExtractCore.int64 g + decode _cx = Right . Terms.int64 + +int8 :: TermCoder Int8 +int8 = TermCoder Types.int8 encode decode + where + encode _cx g = ExtractCore.int8 g + decode _cx = Right . Terms.int8 + +integerType :: TermCoder IntegerType +integerType = TermCoder (TypeVariable _IntegerType) encode decode + where + encode _cx g term = case DecodeCore.integerType g term of + Left err -> Left $ Error.ErrorDecoding err + Right v -> Right v + decode _cx = Right . EncodeCore.integerType + +integerValue :: TermCoder IntegerValue +integerValue = TermCoder (TypeVariable _IntegerValue) encode decode + where + encode _cx g = ExtractCore.integerValue g + decode _cx = Right . Terms.integer + +list :: TermCoder x -> TermCoder [x] +list els = TermCoder (Types.list $ termCoderType els) encode decode + where + encode cx g = ExtractCore.listOf (termCoderEncode els cx g) g + decode cx l = Terms.list <$> mapM (termCoderDecode els cx) l + +literal :: TermCoder Literal +literal = TermCoder (TypeVariable _Literal) encode decode + where + encode _cx g = ExtractCore.literal g + decode _cx = Right . Terms.literal + +literalType :: TermCoder LiteralType +literalType = TermCoder (TypeVariable _LiteralType) encode decode + where + encode _cx g term = case DecodeCore.literalType g term of + Left err -> Left $ Error.ErrorDecoding err + Right v -> Right v + decode _cx = Right . EncodeCore.literalType + +map :: Ord k => TermCoder k -> TermCoder v -> TermCoder (M.Map k v) +map keys values = TermCoder (Types.map (termCoderType keys) (termCoderType values)) encode decode + where + encode cx g = ExtractCore.map (termCoderEncode keys cx g) (termCoderEncode values cx g) g + decode cx m = Terms.map . M.fromList <$> mapM decodePair (M.toList m) + where + decodePair (k, v) = do + ke <- termCoderDecode keys cx k + ve <- termCoderDecode values cx v + return (ke, ve) + +optional :: TermCoder x -> TermCoder (Y.Maybe x) +optional mel = TermCoder (Types.optional $ termCoderType mel) encode decode + where + encode cx g = ExtractCore.optionalTerm (termCoderEncode mel cx g) g + decode cx mv = Terms.optional <$> case mv of + Nothing -> pure Nothing + Just v -> Just <$> termCoderDecode mel cx v + +-- | A helper to create an Error from a string message and context +otherErr :: Typing.InferenceContext -> String -> Error.Error +otherErr _cx msg = Error.ErrorOther (Error.OtherError msg) + +-- | A type variable specification with optional class constraints +data TypeVar = TypeVar { + typeVarName :: String, + typeVarClasses :: [Name] +} + +pair :: TermCoder x -> TermCoder y -> TermCoder (x, y) +pair xCoder yCoder = TermCoder (Types.pair (termCoderType xCoder) (termCoderType yCoder)) encode decode + where + encode cx g = ExtractCore.pair (termCoderEncode xCoder cx g) (termCoderEncode yCoder cx g) g + decode cx (x, y) = do + xTerm <- termCoderDecode xCoder cx x + yTerm <- termCoderDecode yCoder cx y + return $ Terms.pair xTerm yTerm + +prim0 :: ToPrimName n => n -> x -> [TypeVar] -> TermCoder x -> Primitive +prim0 n value vars output = Primitive (defaultPrimitiveDefinition name typ) impl + where + name = toPrimName n + typ = buildTypeScheme vars $ termCoderType output + impl _g _args = termCoderDecode output primCx value + +prim1 :: ToPrimName n => n -> (x -> y) -> [TypeVar] -> TermCoder x -> TermCoder y -> Primitive +prim1 n compute vars input1 output = Primitive (defaultPrimitiveDefinition name typ) impl + where + name = toPrimName n + typ = buildTypeScheme vars $ Types.functionMany [ + termCoderType input1, + termCoderType output] + impl g args = do + ExtractCore.nArgs name 1 args + arg1 <- termCoderEncode input1 primCx g (args !! 0) + termCoderDecode output primCx $ compute arg1 + +prim2 :: ToPrimName n => n -> (x -> y -> z) -> [TypeVar] -> TermCoder x -> TermCoder y -> TermCoder z -> Primitive +prim2 n compute vars input1 input2 output = Primitive (defaultPrimitiveDefinition name typ) impl + where + name = toPrimName n + typ = buildTypeScheme vars $ Types.functionMany [ + termCoderType input1, + termCoderType input2, + termCoderType output] + impl g args = do + ExtractCore.nArgs name 2 args + arg1 <- termCoderEncode input1 primCx g (args !! 0) + arg2 <- termCoderEncode input2 primCx g (args !! 1) + termCoderDecode output primCx $ compute arg1 arg2 + +prim3 :: ToPrimName n => n -> (w -> x -> y -> z) -> [TypeVar] -> TermCoder w -> TermCoder x -> TermCoder y -> TermCoder z -> Primitive +prim3 n compute vars input1 input2 input3 output = Primitive (defaultPrimitiveDefinition name typ) impl + where + name = toPrimName n + typ = buildTypeScheme vars $ Types.functionMany [ + termCoderType input1, + termCoderType input2, + termCoderType input3, + termCoderType output] + impl g args = do + ExtractCore.nArgs name 3 args + arg1 <- termCoderEncode input1 primCx g (args !! 0) + arg2 <- termCoderEncode input2 primCx g (args !! 1) + arg3 <- termCoderEncode input3 primCx g (args !! 2) + termCoderDecode output primCx $ compute arg1 arg2 arg3 + +set :: Ord x => TermCoder x -> TermCoder (S.Set x) +set els = TermCoder (Types.set $ termCoderType els) encode decode + where + encode cx g = ExtractCore.setOf (termCoderEncode els cx g) g + decode cx s = Terms.set . S.fromList <$> mapM (termCoderDecode els cx) (S.toList s) + +string :: TermCoder String +string = TermCoder Types.string encode decode + where + encode _cx g = ExtractCore.string g + decode _cx = Right . Terms.string + +term :: TermCoder Term +term = TermCoder (TypeVariable _Term) encode decode + where + encode _cx _g = Right + decode _cx = Right + +-- | Get just the variable names from a list of TypeVars +typeVarNames :: [TypeVar] -> [String] +typeVarNames = fmap typeVarName + +-- | Convert a list of TypeVars to the format needed by polyConstrained +-- Filters out variables with no constraints +typeVarsToConstraints :: [TypeVar] -> [(String, [Name])] +typeVarsToConstraints = filter (not . L.null . snd) . fmap (\tv -> (typeVarName tv, typeVarClasses tv)) + +type_ :: TermCoder Type +type_ = TermCoder (TypeVariable _Type) encode decode + where + encode _cx g t = case DecodeCore.type_ g t of + Left err -> Left $ Error.ErrorDecoding err + Right v -> Right v + decode _cx = Right . EncodeCore.type_ + +uint16 :: TermCoder Int +uint16 = TermCoder Types.uint16 encode decode + where + encode _cx g = ExtractCore.uint16 g + decode _cx = Right . Terms.uint16 + +uint32 :: TermCoder Int64 +uint32 = TermCoder Types.uint32 encode decode + where + encode _cx g = ExtractCore.uint32 g + decode _cx = Right . Terms.uint32 + +uint64 :: TermCoder Integer +uint64 = TermCoder Types.uint64 encode decode + where + encode _cx g = ExtractCore.uint64 g + decode _cx = Right . Terms.uint64 + +uint8 :: TermCoder Int16 +uint8 = TermCoder Types.uint8 encode decode + where + encode _cx g = ExtractCore.uint8 g + decode _cx = Right . Terms.uint8 + +-- | Create an unconstrained type variable +v :: String -> TypeVar +v name = TypeVar name [] + +-- | Create a type variable with Eq constraint +vEq :: String -> TypeVar +vEq name = TypeVar name [Name "equality"] + +-- | Create a type variable with Ord constraint +vOrd :: String -> TypeVar +vOrd name = TypeVar name [Name "ordering"] + +variable :: String -> TermCoder Term +variable v = TermCoder (Types.var v) encode decode + where + encode _cx _g = Right + decode _cx = Right diff --git a/src/main/haskell/Hydra/Dsl/Terms.hs b/src/main/haskell/Hydra/Dsl/Terms.hs --- a/src/main/haskell/Hydra/Dsl/Terms.hs +++ b/src/main/haskell/Hydra/Dsl/Terms.hs @@ -1,9 +1,12 @@ +{-# LANGUAGE FlexibleInstances #-} + -- | A domain-specific language for constructing Hydra terms in Haskell. module Hydra.Dsl.Terms where import Hydra.Constants import Hydra.Core import Hydra.Graph +import Hydra.Packaging (PrimitiveDefinition, primitiveDefinitionName) import Hydra.Util import Hydra.Dsl.Meta.Common import qualified Hydra.Dsl.Literals as Literals @@ -251,10 +254,24 @@ pair a b = TermPair (a, b) -- | Create a reference to a primitive function. +-- | Things that name a primitive. Lets the term/DSL helpers take a generated +-- 'PrimitiveDefinition' directly (@primitive DefStrings.toUpper@) — keeping the def-modules the +-- single source of truth for primitive names (#473) — while still accepting a raw 'Name'. +-- Defined here (the lowest DSL module) so 'Hydra.Dsl.Prims', 'Hydra.Dsl.Meta.Terms', and +-- 'Hydra.Dsl.Meta.Phantoms' can all share one class without an import cycle. +class ToPrimName a where + toPrimName :: a -> Name + +instance ToPrimName Name where + toPrimName = id + +instance ToPrimName PrimitiveDefinition where + toPrimName = primitiveDefinitionName + -- Uses TermVariable; the name resolves via graphPrimitives fallthrough. --- Example: primitive (Name "hydra.lib.strings.length") -primitive :: Name -> Term -primitive = TermVariable +-- Example: primitive DefStrings.length +primitive :: ToPrimName n => n -> Term +primitive = TermVariable . toPrimName -- | Create a field projection function -- Example: project (Name "Person") (Name "firstName") diff --git a/src/main/haskell/Hydra/Dsl/Tests.hs b/src/main/haskell/Hydra/Dsl/Tests.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Tests.hs @@ -0,0 +1,29 @@ +-- | Convenience functions for writing Hydra test cases + +module Hydra.Dsl.Tests ( + module Hydra.Testing, + module Hydra.Dsl.Libraries, + module Hydra.Dsl.Terms, + module Hydra.Dsl.Tests, +) where + +import Hydra.Core +import Hydra.Testing +import Hydra.Dsl.Libraries +import Hydra.Dsl.Terms + +import qualified Data.List as L +import qualified Data.Set as S + + +intList :: [Int] -> Term +intList els = list (int32 <$> els) + +intListList :: [[Int]] -> Term +intListList lists = list (intList <$> lists) + +stringList :: [String] -> Term +stringList els = list (string <$> els) + +stringSet :: S.Set String -> Term +stringSet strings = set $ S.fromList $ string <$> S.toList strings diff --git a/src/main/haskell/Hydra/Dsl/Types.hs b/src/main/haskell/Hydra/Dsl/Types.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Types.hs @@ -0,0 +1,266 @@ +-- | A domain-specific language for constructing Hydra types in Haskell. +module Hydra.Dsl.Types where + +import Prelude hiding (product) + +import Hydra.Core +import Hydra.Dsl.AsType +import Hydra.Dsl.Meta.Common +import qualified Hydra.Dsl.Terms as Terms + +import qualified Data.List as L +import qualified Data.Map as M +import qualified Data.Set as S + + +-- Operators + +-- | Function type constructor with infix syntax +-- Example: int32 ~> string +-- Use this for more readable function type definitions +infixr 0 ~> +(~>) :: (AsType a, AsType b) => a -> b -> Type +dom ~> cod = function (asType dom) (asType cod) + +-- | Function type constructor with infix syntax (deprecated, use ~> instead) +-- Example: int32 --> string +infixr 0 --> +(-->) :: (AsType a, AsType b) => a -> b -> Type +dom --> cod = function (asType dom) (asType cod) + +-- | Type application operator +-- Example: list @@ int32 +(@@) :: (AsType a, AsType b) => a -> b -> Type +fun @@ arg = apply (asType fun) (asType arg) + +-- | Field definition operator +-- Example: "name">: string +infixr 0 >: +(>:) :: AsType a => String -> a -> FieldType +name>: typ = field name (asType typ) + + +-- | Attach an annotation map to a type, wrapping the map as a TermMap per +-- Hydra's convention (#386 — annotation is now a Term, not a Map). +-- Example: annot (M.fromList [(Name "min", int32 0), (Name "max", int32 100)]) int32 +annot :: AsType a => M.Map Name Term -> a -> Type +annot ann typ = TypeAnnotated $ AnnotatedType (asType typ) (Terms.annotationMapAsTerm ann) + +-- | Apply a type to a type argument +-- Example: apply (var "f") int32 +apply :: (AsType a, AsType b) => a -> b -> Type +apply lhs rhs = TypeApplication (ApplicationType (asType lhs) (asType rhs)) + +-- | Apply a type to multiple type arguments +-- Example: applys (var "Either") [string, int32] +applys :: AsType a => a -> [Type] -> Type +applys t ts = L.foldl apply (asType t) ts + +-- | Arbitrary-precision integer type +bigint :: Type +bigint = integer IntegerTypeBigint + +-- | Binary data type +binary :: Type +binary = literal LiteralTypeBinary + +-- | Boolean type +boolean :: Type +boolean = literal LiteralTypeBoolean + +-- | Arbitrary-precision decimal type +decimal :: Type +decimal = literal LiteralTypeDecimal + +-- | Create an either type (a choice between two types) +-- Example: either_ string int32 +either_ :: (AsType a, AsType b) => a -> b -> Type +either_ left right = TypeEither $ EitherType (asType left) (asType right) + +-- | Create an enum type with the given variant names (conventionally in camelCase) +-- Example: enum ["red", "green", "blue"] +enum :: [String] -> Type +enum names = union $ (`field` unit) <$> names + +-- | Create a field with the given name and type +-- Example: field "age" int32 +field :: AsType a => String -> a -> FieldType +field fn t = FieldType (Name fn) (asType t) + +-- | Create a floating point type with the specified precision +-- Example: float FloatTypeFloat32 +float :: FloatType -> Type +float = literal . LiteralTypeFloat + +-- | 32-bit floating point type +float32 :: Type +float32 = float FloatTypeFloat32 + +-- | 64-bit floating point type +float64 :: Type +float64 = float FloatTypeFloat64 + +-- | Create a universally quantified type (polymorphic type) with a singe variable +-- Example: forAll "a" (var "a" --> var "a") +-- This creates the polymorphic identity function type: ∀a. a -> a +-- Universal quantification introduces type variables that can be used in the body +forAll :: AsType a => String -> a -> Type +forAll v body = TypeForall $ ForallType (Name v) (asType body) + +-- | Universal quantification with multiple variables +-- Example: forAlls ["a", "b"] (var "a" --> var "b") +forAlls :: AsType a => [String] -> a -> Type +forAlls vs body = L.foldr forAll (asType body) vs + +-- | Create a function type +-- Example: function int32 string +function :: (AsType a, AsType b) => a -> b -> Type +function dom cod = TypeFunction $ FunctionType (asType dom) (asType cod) + +-- | Create an n-ary function type +-- Example: functionMany [int32, string, boolean] +functionMany :: [Type] -> Type +functionMany ts = L.foldl (\cod dom -> function dom cod) (L.head r) (L.tail r) + where + r = L.reverse ts + +-- | 16-bit signed integer type +int16 :: Type +int16 = integer IntegerTypeInt16 + +-- | 32-bit signed integer type +int32 :: Type +int32 = integer IntegerTypeInt32 + +-- | 64-bit signed integer type +int64 :: Type +int64 = integer IntegerTypeInt64 + +-- | 8-bit signed integer type +int8 :: Type +int8 = integer IntegerTypeInt8 + +-- | Create an integer type with the specified bit width +-- Example: integer IntegerTypeInt32 +integer :: IntegerType -> Type +integer = literal . LiteralTypeInteger + +-- | List type +-- Example: list string +list :: AsType a => a -> Type +list = TypeList . asType + +-- | Literal primitive type +-- Example: literal LiteralTypeString +literal :: LiteralType -> Type +literal = TypeLiteral + +-- | Map/dictionary type with key and value types +-- Example: map string int32 +map :: (AsType a, AsType b) => a -> b -> Type +map keys vals = TypeMap $ MapType (asType keys) (asType vals) + +-- | Create a monomorphic type scheme +-- Example: mono int32 +mono :: AsType a => a -> TypeScheme +mono t = TypeScheme [] (asType t) Nothing + +-- | Non-negative 32-bit integer type +-- Currently an alias for int32; intended for semantic annotation +-- In future versions, this may include validation constraints +nonNegativeInt32 :: Type +nonNegativeInt32 = int32 + +-- | Optional (nullable) type +-- Example: optional string +optional :: AsType a => a -> Type +optional = TypeOptional . asType + +-- | Create a pair type +-- Example: pair string int32 +pair :: (AsType a, AsType b) => a -> b -> Type +pair first second = TypePair $ PairType (asType first) (asType second) + +-- | Create a polymorphic type scheme with explicit type variables +-- Example: poly ["a", "b"] (var "a" --> var "b") +-- This represents a type forall a b. a -> b that can be instantiated with different types +poly :: AsType a => [String] -> a -> TypeScheme +poly vs t = TypeScheme (Name <$> vs) (asType t) Nothing + +-- | Create a polymorphic type scheme with explicit type variables and constraints +-- Example: polyConstrained [("a", [Name "hydra.core.Eq"])] (var "a" --> var "a" --> boolean) +-- This represents a type forall a. (Eq a) => a -> a -> Boolean +polyConstrained :: AsType a => [(String, [Name])] -> a -> TypeScheme +polyConstrained vsWithConstraints t = TypeScheme vars (asType t) (Just constraintMap) + where + vars = Name . fst <$> vsWithConstraints + constraintMap = M.fromList + [(Name v, TypeVariableConstraints (TypeClassConstraintSimple <$> classes)) | (v, classes) <- vsWithConstraints, not (L.null classes)] + +-- | Create a product type using nested pairs (deprecated: use pair directly) +-- Example: product [string, int32, boolean] creates pair string (pair int32 boolean) +product :: [Type] -> Type +product [] = unit +product [a] = a +product [a, b] = pair a b +product (a:rest) = pair a (product rest) + +-- | Create a record type with the given fields +-- Example: record ["name">: string, "age">: int32] +record :: [FieldType] -> Type +record = TypeRecord + +-- | Set type +-- Example: set string +set :: AsType a => a -> Type +set = TypeSet . asType + +-- | String type +string :: Type +string = literal LiteralTypeString + +-- | 16-bit unsigned integer type +uint16 :: Type +uint16 = integer IntegerTypeUint16 + +-- | 32-bit unsigned integer type +uint32 :: Type +uint32 = integer IntegerTypeUint32 + +-- | 64-bit unsigned integer type +uint64 :: Type +uint64 = integer IntegerTypeUint64 + +-- | 8-bit unsigned integer type +uint8 :: Type +uint8 = integer IntegerTypeUint8 + +-- | Create a union type with the given variants +-- Example: union ["success">: int32, "failure">: string] +-- This creates a tagged union type (sum type with named variants) +-- Similar to sum [int32, string] but with named branches +union :: [FieldType] -> Type +union = TypeUnion + +-- | Unit type (empty record type) +unit :: Type +unit = TypeUnit + +-- | Create a type variable with the given name (alias for 'variable') +-- Example: var "a" +var :: String -> Type +var = variable + +-- | Create a type variable with the given name +-- Example: variable "a" +variable :: String -> Type +variable = TypeVariable . Name + +-- | Void type (uninhabited / bottom type) +void :: Type +void = TypeVoid + +-- | Create a wrapped type (newtype) with a provided base type +-- Example: wrap string +wrap :: AsType a => a -> Type +wrap = TypeWrap . asType diff --git a/src/main/haskell/Hydra/Encode/Error/Checking.hs b/src/main/haskell/Hydra/Encode/Error/Checking.hs --- a/src/main/haskell/Hydra/Encode/Error/Checking.hs +++ b/src/main/haskell/Hydra/Encode/Error/Checking.hs @@ -199,7 +199,7 @@ Core.fieldName = (Core.Name "termVariant"), Core.fieldTerm = (Variants.termVariant (Checking.unsupportedTermVariantErrorTermVariant x))}]}) -- | Encoder for hydra.error.checking.UntypedLambdaError -untypedLambdaError :: t0 -> Core.Term +untypedLambdaError :: Checking.UntypedLambdaError -> Core.Term untypedLambdaError x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), diff --git a/src/main/haskell/Hydra/Encode/Error/Packaging.hs b/src/main/haskell/Hydra/Encode/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Error/Packaging.hs @@ -0,0 +1,197 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term encoders for hydra.error.packaging + +module Hydra.Encode.Error.Packaging where +import qualified Hydra.Core as Core +import qualified Hydra.Encode.Core as EncodeCore +import qualified Hydra.Encode.Packaging as EncodePackaging +import qualified Hydra.Encode.Util as Util +import qualified Hydra.Error.Packaging as ErrorPackaging +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Encoder for hydra.error.packaging.ConflictingModuleNameError +conflictingModuleNameError :: ErrorPackaging.ConflictingModuleNameError -> Core.Term +conflictingModuleNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "first"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.conflictingModuleNameErrorFirst x))}, + Core.Field { + Core.fieldName = (Core.Name "second"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.conflictingModuleNameErrorSecond x))}]}) +-- | Encoder for hydra.error.packaging.ConflictingVariantNameError +conflictingVariantNameError :: ErrorPackaging.ConflictingVariantNameError -> Core.Term +conflictingVariantNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.conflictingVariantNameErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "typeName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.conflictingVariantNameErrorTypeName x))}, + Core.Field { + Core.fieldName = (Core.Name "variantName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.conflictingVariantNameErrorVariantName x))}, + Core.Field { + Core.fieldName = (Core.Name "conflictingName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.conflictingVariantNameErrorConflictingName x))}]}) +-- | Encoder for hydra.error.packaging.DefinitionNotInModuleNameError +definitionNotInModuleNameError :: ErrorPackaging.DefinitionNotInModuleNameError -> Core.Term +definitionNotInModuleNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.definitionNotInModuleNameErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "name"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.definitionNotInModuleNameErrorName x))}]}) +-- | Encoder for hydra.error.packaging.DefinitionsOutOfOrderError +definitionsOutOfOrderError :: ErrorPackaging.DefinitionsOutOfOrderError -> Core.Term +definitionsOutOfOrderError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.definitionsOutOfOrderErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "precedingName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.definitionsOutOfOrderErrorPrecedingName x))}, + Core.Field { + Core.fieldName = (Core.Name "followingName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.definitionsOutOfOrderErrorFollowingName x))}]}) +-- | Encoder for hydra.error.packaging.DuplicateDefinitionNameError +duplicateDefinitionNameError :: ErrorPackaging.DuplicateDefinitionNameError -> Core.Term +duplicateDefinitionNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.duplicateDefinitionNameErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "name"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.duplicateDefinitionNameErrorName x))}]}) +-- | Encoder for hydra.error.packaging.DuplicateModuleNameError +duplicateModuleNameError :: ErrorPackaging.DuplicateModuleNameError -> Core.Term +duplicateModuleNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.duplicateModuleNameErrorModuleName x))}]}) +-- | Encoder for hydra.error.packaging.InvalidDefinitionNameError +invalidDefinitionNameError :: ErrorPackaging.InvalidDefinitionNameError -> Core.Term +invalidDefinitionNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.invalidDefinitionNameErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "name"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.invalidDefinitionNameErrorName x))}, + Core.Field { + Core.fieldName = (Core.Name "expectedConvention"), + Core.fieldTerm = (Util.caseConvention (ErrorPackaging.invalidDefinitionNameErrorExpectedConvention x))}]}) +-- | Encoder for hydra.error.packaging.InvalidModuleError +invalidModuleError :: ErrorPackaging.InvalidModuleError -> Core.Term +invalidModuleError x = + case x of + ErrorPackaging.InvalidModuleErrorConflictingVariantName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "conflictingVariantName"), + Core.fieldTerm = (conflictingVariantNameError v0)}}) + ErrorPackaging.InvalidModuleErrorDefinitionNotInModuleName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "definitionNotInModuleName"), + Core.fieldTerm = (definitionNotInModuleNameError v0)}}) + ErrorPackaging.InvalidModuleErrorDefinitionsOutOfOrder v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "definitionsOutOfOrder"), + Core.fieldTerm = (definitionsOutOfOrderError v0)}}) + ErrorPackaging.InvalidModuleErrorDuplicateDefinitionName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "duplicateDefinitionName"), + Core.fieldTerm = (duplicateDefinitionNameError v0)}}) + ErrorPackaging.InvalidModuleErrorInvalidDefinitionName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "invalidDefinitionName"), + Core.fieldTerm = (invalidDefinitionNameError v0)}}) + ErrorPackaging.InvalidModuleErrorInvalidModuleNameConvention v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "invalidModuleNameConvention"), + Core.fieldTerm = (invalidModuleNameConventionError v0)}}) + ErrorPackaging.InvalidModuleErrorMissingDocumentation v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "missingDocumentation"), + Core.fieldTerm = (missingDocumentationError v0)}}) +-- | Encoder for hydra.error.packaging.InvalidModuleNameConventionError +invalidModuleNameConventionError :: ErrorPackaging.InvalidModuleNameConventionError -> Core.Term +invalidModuleNameConventionError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.invalidModuleNameConventionErrorModuleName x))}]}) +-- | Encoder for hydra.error.packaging.InvalidPackageError +invalidPackageError :: ErrorPackaging.InvalidPackageError -> Core.Term +invalidPackageError x = + case x of + ErrorPackaging.InvalidPackageErrorConflictingModuleName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "conflictingModuleName"), + Core.fieldTerm = (conflictingModuleNameError v0)}}) + ErrorPackaging.InvalidPackageErrorDuplicateModuleName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "duplicateModuleName"), + Core.fieldTerm = (duplicateModuleNameError v0)}}) + ErrorPackaging.InvalidPackageErrorInvalidModule v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "invalidModule"), + Core.fieldTerm = (invalidModuleError v0)}}) + ErrorPackaging.InvalidPackageErrorInvalidPackageName v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "invalidPackageName"), + Core.fieldTerm = (invalidPackageNameError v0)}}) +-- | Encoder for hydra.error.packaging.InvalidPackageNameError +invalidPackageNameError :: ErrorPackaging.InvalidPackageNameError -> Core.Term +invalidPackageNameError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "packageName"), + Core.fieldTerm = (EncodePackaging.packageName (ErrorPackaging.invalidPackageNameErrorPackageName x))}]}) +-- | Encoder for hydra.error.packaging.MissingDocumentationError +missingDocumentationError :: ErrorPackaging.MissingDocumentationError -> Core.Term +missingDocumentationError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.missingDocumentationErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "name"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.missingDocumentationErrorName x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Errors.hs b/src/main/haskell/Hydra/Encode/Errors.hs --- a/src/main/haskell/Hydra/Encode/Errors.hs +++ b/src/main/haskell/Hydra/Encode/Errors.hs @@ -19,7 +19,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unDecodingError x))}) -- | Encoder for hydra.errors.EmptyListError -emptyListError :: t0 -> Core.Term +emptyListError :: () -> Core.Term emptyListError _ = Core.TermUnit -- | Encoder for hydra.errors.Error error :: Errors.Error -> Core.Term @@ -204,7 +204,7 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (EncodeCore.name (Errors.noSuchPrimitiveErrorName x))}]}) -- | Encoder for hydra.errors.NotEnoughCasesError -notEnoughCasesError :: t0 -> Core.Term +notEnoughCasesError :: () -> Core.Term notEnoughCasesError _ = Core.TermUnit -- | Encoder for hydra.errors.OtherError otherError :: Errors.OtherError -> Core.Term diff --git a/src/main/haskell/Hydra/Encode/Parsing.hs b/src/main/haskell/Hydra/Encode/Parsing.hs --- a/src/main/haskell/Hydra/Encode/Parsing.hs +++ b/src/main/haskell/Hydra/Encode/Parsing.hs @@ -20,7 +20,7 @@ Core.fieldName = (Core.Name "remainder"), Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseErrorRemainder x))}]}) -- | Encoder for hydra.parsing.ParseResult -parseResult :: (t0 -> Core.Term) -> Parsing.ParseResult t0 -> Core.Term +parseResult :: (a -> Core.Term) -> Parsing.ParseResult a -> Core.Term parseResult a x = case x of Parsing.ParseResultSuccess v0 -> Core.TermInject (Core.Injection { @@ -34,7 +34,7 @@ Core.fieldName = (Core.Name "failure"), Core.fieldTerm = (parseError v0)}}) -- | Encoder for hydra.parsing.ParseSuccess -parseSuccess :: (t0 -> Core.Term) -> Parsing.ParseSuccess t0 -> Core.Term +parseSuccess :: (a -> Core.Term) -> Parsing.ParseSuccess a -> Core.Term parseSuccess a x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), diff --git a/src/main/haskell/Hydra/Encode/Relational.hs b/src/main/haskell/Hydra/Encode/Relational.hs --- a/src/main/haskell/Hydra/Encode/Relational.hs +++ b/src/main/haskell/Hydra/Encode/Relational.hs @@ -17,7 +17,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"), Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Relational.unColumnName x))}) -- | Encoder for hydra.relational.ColumnSchema -columnSchema :: (t0 -> Core.Term) -> Relational.ColumnSchema t0 -> Core.Term +columnSchema :: (t -> Core.Term) -> Relational.ColumnSchema t -> Core.Term columnSchema t x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), @@ -47,7 +47,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"), Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map columnName xs)) (Relational.unPrimaryKey x))}) -- | Encoder for hydra.relational.Relation -relation :: (t0 -> Core.Term) -> Relational.Relation t0 -> Core.Term +relation :: (v -> Core.Term) -> Relational.Relation v -> Core.Term relation v x = Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"), @@ -59,7 +59,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"), Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Relational.unRelationName x))}) -- | Encoder for hydra.relational.RelationSchema -relationSchema :: (t0 -> Core.Term) -> Relational.RelationSchema t0 -> Core.Term +relationSchema :: (t -> Core.Term) -> Relational.RelationSchema t -> Core.Term relationSchema t x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), @@ -77,13 +77,13 @@ Core.fieldName = (Core.Name "foreignKeys"), Core.fieldTerm = ((\xs -> Core.TermList (Lists.map foreignKey xs)) (Relational.relationSchemaForeignKeys x))}]}) -- | Encoder for hydra.relational.Relationship -relationship :: Ord t0 => ((t0 -> Core.Term) -> Relational.Relationship t0 -> Core.Term) +relationship :: Ord v => ((v -> Core.Term) -> Relational.Relationship v -> Core.Term) relationship v x = Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"), Core.wrappedTermBody = ((\s -> Core.TermSet (Sets.map (\m -> Core.TermMap (Maps.bimap columnName v m)) s)) (Relational.unRelationship x))}) -- | Encoder for hydra.relational.Row -row :: (t0 -> Core.Term) -> Relational.Row t0 -> Core.Term +row :: (v -> Core.Term) -> Relational.Row v -> Core.Term row v x = Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"), diff --git a/src/main/haskell/Hydra/Encode/Tabular.hs b/src/main/haskell/Hydra/Encode/Tabular.hs --- a/src/main/haskell/Hydra/Encode/Tabular.hs +++ b/src/main/haskell/Hydra/Encode/Tabular.hs @@ -23,7 +23,7 @@ Core.fieldName = (Core.Name "type"), Core.fieldTerm = (EncodeCore.type_ (Tabular.columnTypeType x))}]}) -- | Encoder for hydra.tabular.DataRow -dataRow :: (t0 -> Core.Term) -> Tabular.DataRow t0 -> Core.Term +dataRow :: (v -> Core.Term) -> Tabular.DataRow v -> Core.Term dataRow v x = Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"), @@ -35,7 +35,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"), Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Tabular.unHeaderRow x))}) -- | Encoder for hydra.tabular.Table -table :: (t0 -> Core.Term) -> Tabular.Table t0 -> Core.Term +table :: (v -> Core.Term) -> Tabular.Table v -> Core.Term table v x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.tabular.Table"), diff --git a/src/main/haskell/Hydra/Encode/Topology.hs b/src/main/haskell/Hydra/Encode/Topology.hs --- a/src/main/haskell/Hydra/Encode/Topology.hs +++ b/src/main/haskell/Hydra/Encode/Topology.hs @@ -12,7 +12,7 @@ import qualified Data.Scientific as Sci import qualified Data.Map as M -- | Encoder for hydra.topology.Graph -graph :: M.Map Int [Int] -> Core.Term +graph :: M.Map Topology.Vertex [Topology.Vertex] -> Core.Term graph m = Core.TermMap (Maps.bimap vertex (\xs -> Core.TermList (Lists.map vertex xs)) m) -- | Encoder for hydra.topology.TarjanState tarjanState :: Topology.TarjanState -> Core.Term diff --git a/src/main/haskell/Hydra/Encode/Typed.hs b/src/main/haskell/Hydra/Encode/Typed.hs --- a/src/main/haskell/Hydra/Encode/Typed.hs +++ b/src/main/haskell/Hydra/Encode/Typed.hs @@ -8,7 +8,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci -- | Encoder for hydra.typed.TypedBinding -typedBinding :: t0 -> Typed.TypedBinding t1 -> Core.Term +typedBinding :: (a -> Core.Term) -> Typed.TypedBinding a -> Core.Term typedBinding a x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.typed.TypedBinding"), @@ -20,13 +20,13 @@ Core.fieldName = (Core.Name "term"), Core.fieldTerm = (typedTerm a (Typed.typedBindingTerm x))}]}) -- | Encoder for hydra.typed.TypedTerm -typedTerm :: t0 -> Typed.TypedTerm t1 -> Core.Term +typedTerm :: (a -> Core.Term) -> Typed.TypedTerm a -> Core.Term typedTerm a x = Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"), Core.wrappedTermBody = (EncodeCore.term (Typed.unTypedTerm x))}) -- | Encoder for hydra.typed.TypedTermDefinition -typedTermDefinition :: t0 -> Typed.TypedTermDefinition t1 -> Core.Term +typedTermDefinition :: (a -> Core.Term) -> Typed.TypedTermDefinition a -> Core.Term typedTermDefinition a x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.typed.TypedTermDefinition"), diff --git a/src/main/haskell/Hydra/Encode/Typing.hs b/src/main/haskell/Hydra/Encode/Typing.hs --- a/src/main/haskell/Hydra/Encode/Typing.hs +++ b/src/main/haskell/Hydra/Encode/Typing.hs @@ -12,7 +12,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci -- | Encoder for hydra.typing.FunctionStructure -functionStructure :: (t0 -> Core.Term) -> Typing.FunctionStructure t0 -> Core.Term +functionStructure :: (env -> Core.Term) -> Typing.FunctionStructure env -> Core.Term functionStructure env x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), diff --git a/src/main/haskell/Hydra/Encode/Util.hs b/src/main/haskell/Hydra/Encode/Util.hs --- a/src/main/haskell/Hydra/Encode/Util.hs +++ b/src/main/haskell/Hydra/Encode/Util.hs @@ -61,7 +61,7 @@ Core.wrappedTermTypeName = (Core.Name "hydra.util.FileExtension"), Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Util.unFileExtension x))}) -- | Encoder for hydra.util.ModuleNames -moduleNames :: (t0 -> Core.Term) -> Util.ModuleNames t0 -> Core.Term +moduleNames :: (n -> Core.Term) -> Util.ModuleNames n -> Core.Term moduleNames n x = Core.TermRecord (Core.Record { Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"), diff --git a/src/main/haskell/Hydra/Encode/Validation.hs b/src/main/haskell/Hydra/Encode/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Validation.hs @@ -0,0 +1,42 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term encoders for hydra.validation + +module Hydra.Encode.Validation where +import qualified Hydra.Core as Core +import qualified Hydra.Encode.Core as EncodeCore +import qualified Hydra.Encode.Error.Core as ErrorCore +import qualified Hydra.Haskell.Lib.Lists as Lists +import qualified Hydra.Haskell.Lib.Sets as Sets +import qualified Hydra.Validation as Validation +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Encoder for hydra.validation.ValidationProfile +validationProfile :: Validation.ValidationProfile -> Core.Term +validationProfile x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "errorRules"), + Core.fieldTerm = ((\s -> Core.TermSet (Sets.map EncodeCore.name s)) (Validation.validationProfileErrorRules x))}, + Core.Field { + Core.fieldName = (Core.Name "warningRules"), + Core.fieldTerm = ((\s -> Core.TermSet (Sets.map EncodeCore.name s)) (Validation.validationProfileWarningRules x))}, + Core.Field { + Core.fieldName = (Core.Name "maxErrors"), + Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Validation.validationProfileMaxErrors x))}, + Core.Field { + Core.fieldName = (Core.Name "maxWarnings"), + Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Validation.validationProfileMaxWarnings x))}]}) +-- | Encoder for hydra.validation.ValidationResult +validationResult :: (e -> Core.Term) -> Validation.ValidationResult e -> Core.Term +validationResult e x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "errors"), + Core.fieldTerm = ((\xs -> Core.TermList (Lists.map e xs)) (Validation.validationResultErrors x))}, + Core.Field { + Core.fieldName = (Core.Name "warnings"), + Core.fieldTerm = ((\xs -> Core.TermList (Lists.map e xs)) (Validation.validationResultWarnings x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Yaml/Model.hs b/src/main/haskell/Hydra/Encode/Yaml/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Yaml/Model.hs @@ -0,0 +1,64 @@ +-- Note: this is an automatically generated file. Do not edit. +-- | Term encoders for hydra.yaml.model + +module Hydra.Encode.Yaml.Model where +import qualified Hydra.Core as Core +import qualified Hydra.Encode.Core as EncodeCore +import qualified Hydra.Haskell.Lib.Lists as Lists +import qualified Hydra.Haskell.Lib.Maps as Maps +import qualified Hydra.Yaml.Model as Model +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +-- | Encoder for hydra.yaml.model.Node +node :: Model.Node -> Core.Term +node x = + case x of + Model.NodeMapping v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "mapping"), + Core.fieldTerm = (Core.TermMap (Maps.bimap node node v0))}}) + Model.NodeScalar v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "scalar"), + Core.fieldTerm = (scalar v0)}}) + Model.NodeSequence v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "sequence"), + Core.fieldTerm = (Core.TermList (Lists.map node v0))}}) +-- | Encoder for hydra.yaml.model.Scalar +scalar :: Model.Scalar -> Core.Term +scalar x = + case x of + Model.ScalarBool v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "bool"), + Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}}) + Model.ScalarDecimal v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "decimal"), + Core.fieldTerm = (Core.TermLiteral (Core.LiteralDecimal v0))}}) + Model.ScalarFloat v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "float"), + Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v0)))}}) + Model.ScalarInt v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "int"), + Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v0)))}}) + Model.ScalarNull -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "null"), + Core.fieldTerm = Core.TermUnit}}) + Model.ScalarStr v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "str"), + Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) diff --git a/src/main/haskell/Hydra/Encoding.hs b/src/main/haskell/Hydra/Encoding.hs --- a/src/main/haskell/Hydra/Encoding.hs +++ b/src/main/haskell/Hydra/Encoding.hs @@ -73,7 +73,9 @@ encodeEitherType et = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (encoderFullResultType (Core.eitherTypeLeft et)), + Core.eitherTypeRight = (encoderFullResultType (Core.eitherTypeRight et))}))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -81,7 +83,15 @@ Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bimap")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.eithers.bimap")), + Core.typeApplicationTermType = (encoderFullResultType (Core.eitherTypeLeft et))})), + Core.typeApplicationTermType = (encoderFullResultType (Core.eitherTypeRight et))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType (Core.eitherTypeLeft et))})), Core.applicationArgument = (encodeType (Core.eitherTypeRight et))})), Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}}))}) @@ -90,7 +100,7 @@ encodeFieldValue typeName fieldName fieldType = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (encoderFullResultType fieldType)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -113,7 +123,9 @@ encodeForallType ft = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter ft)), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.forallTypeParameter ft)), + Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))), Core.lambdaBody = (encodeType (Core.forallTypeBody ft))}) -- | Encode an Injection as a term encodeInjection :: Core.Name -> Core.Name -> Core.Term -> Core.Term @@ -157,14 +169,18 @@ encodeListType elemType = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeList (encoderFullResultType elemType))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.typeApplicationTermType = (encoderFullResultType elemType)})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType elemType)})), Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))}) -- | Generate an encoder for a literal type @@ -173,7 +189,7 @@ case x of Core.LiteralTypeBinary -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeBinary)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -185,7 +201,7 @@ Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}) Core.LiteralTypeBoolean -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeBoolean)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -197,7 +213,7 @@ Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}) Core.LiteralTypeDecimal -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeDecimal)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -209,7 +225,7 @@ Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}) Core.LiteralTypeString -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -221,7 +237,7 @@ Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}) Core.LiteralTypeInteger v0 -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger v0))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -233,7 +249,7 @@ Core.fieldTerm = (encodeIntegerValue v0 (Core.TermVariable (Core.Name "x")))}}))}}))}) Core.LiteralTypeFloat v0 -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeFloat v0))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -252,7 +268,9 @@ encodeMapType mt = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeMap (Core.MapType { + Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys mt)), + Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues mt))}))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -260,7 +278,15 @@ Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), + Core.typeApplicationTermType = (encoderFullResultType (Core.mapTypeKeys mt))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (encoderFullResultType (Core.mapTypeValues mt))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType (Core.mapTypeKeys mt))})), Core.applicationArgument = (encodeType (Core.mapTypeValues mt))})), Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))}) @@ -320,14 +346,18 @@ encodeOptionalType elemType = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeOptional (encoderFullResultType elemType))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { Core.fieldName = (Core.Name "optional"), Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), + Core.typeApplicationTermType = (encoderFullResultType elemType)})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType elemType)})), Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))}) -- | Generate an encoder for a pair type @@ -335,7 +365,9 @@ encodePairType pt = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "p"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypePair (Core.PairType { + Core.pairTypeFirst = (encoderFullResultType (Core.pairTypeFirst pt)), + Core.pairTypeSecond = (encoderFullResultType (Core.pairTypeSecond pt))}))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -343,7 +375,15 @@ Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")), + Core.typeApplicationTermType = (encoderFullResultType (Core.pairTypeFirst pt))})), + Core.typeApplicationTermType = (encoderFullResultType (Core.pairTypeSecond pt))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType (Core.pairTypeFirst pt))})), Core.applicationArgument = (encodeType (Core.pairTypeSecond pt))})), Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))}) @@ -355,7 +395,7 @@ encodeRecordTypeNamed ename rt = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeVariable ename)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -388,14 +428,18 @@ encodeSetType elemType = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeSet (encoderFullResultType elemType))), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { Core.fieldName = (Core.Name "set"), Core.fieldTerm = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), + Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { + Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), + Core.typeApplicationTermType = (encoderFullResultType elemType)})), + Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), Core.applicationArgument = (encodeType elemType)})), Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))}) -- | Generate an encoder term for a Type @@ -423,7 +467,7 @@ Core.TypeWrap v0 -> encodeWrappedType v0 Core.TypeUnit -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just Core.TypeUnit), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -431,7 +475,7 @@ Core.fieldTerm = Core.TermUnit}}))}) Core.TypeVoid -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just Core.TypeUnit), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -453,7 +497,9 @@ Core.TypeEither v0 -> encodeEitherType v0 Core.TypeForall v0 -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter v0)), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.forallTypeParameter v0)), + Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))), Core.lambdaBody = (encodeTypeNamed ename (Core.forallTypeBody v0))}) Core.TypeFunction _ -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), @@ -470,7 +516,7 @@ Core.TypeWrap v0 -> encodeWrappedTypeNamed ename v0 Core.TypeUnit -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just Core.TypeUnit), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -478,7 +524,7 @@ Core.fieldTerm = Core.TermUnit}}))}) Core.TypeVoid -> Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just Core.TypeUnit), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -509,7 +555,7 @@ encodeWrappedTypeNamed ename wt = Core.TermLambda (Core.Lambda { Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, + Core.lambdaDomain = (Just (Core.TypeVariable ename)), Core.lambdaBody = (Core.TermInject (Core.Injection { Core.injectionTypeName = (Core.Name "hydra.core.Term"), Core.injectionField = Core.Field { @@ -587,7 +633,7 @@ Core.applicationTypeFunction = (encoderFullResultType (Core.forallTypeBody v0)), Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") + Core.TypeLiteral v0 -> Core.TypeLiteral v0 Core.TypeMap v0 -> Core.TypeMap (Core.MapType { Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)), Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))}) @@ -601,7 +647,7 @@ Core.TypeUnit -> Core.TypeUnit Core.TypeVariable v0 -> Core.TypeVariable v0 Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap _ -> Core.TypeVariable (Core.Name "hydra.core.Term") + Core.TypeWrap v0 -> encoderFullResultType v0 _ -> Core.TypeVariable (Core.Name "hydra.core.Term") -- | Get full result type for encoder input, using element name for nominal types encoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type @@ -618,7 +664,7 @@ Core.applicationTypeFunction = (encoderFullResultTypeNamed ename (Core.forallTypeBody v0)), Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") + Core.TypeLiteral v0 -> Core.TypeLiteral v0 Core.TypeMap v0 -> Core.TypeMap (Core.MapType { Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)), Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))}) diff --git a/src/main/haskell/Hydra/Graph.hs b/src/main/haskell/Hydra/Graph.hs --- a/src/main/haskell/Hydra/Graph.hs +++ b/src/main/haskell/Hydra/Graph.hs @@ -56,8 +56,8 @@ Primitive { -- | The host-independent declarative metadata for the primitive: name, description, signature, totality and purity flags, and an optional reference implementation. primitiveDefinition :: Packaging.PrimitiveDefinition, - -- | A concrete, host-specific implementation of the primitive function: a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive can return an unreduced applicative term and let the outer reducer fold it. The current carrier still threads `InferenceContext` and `Graph` for historical encode/decode and reducer-callback plumbing; no primitive's compute logic uses them, and they are slated for removal (https://github.com/CategoricalData/hydra/issues/446), sequenced with the `defaultImplementation` integration tracked in https://github.com/CategoricalData/hydra/issues/437. - primitiveImplementation :: (Typing.InferenceContext -> Graph -> [Core.Term] -> Either Errors.Error Core.Term)} + -- | A concrete, host-specific implementation of the primitive function: given the current graph, a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive whose result shape is fixed by its data argument can return an unreduced applicative term and let the outer reducer fold it (no graph needed). The graph is retained for the higher-order primitives that must evaluate a function argument mid-computation (e.g. lists.filter): evaluating that function resolves primitive names against the graph's primitive table. The legacy `InferenceContext` parameter was vestigial and has been removed (https://github.com/CategoricalData/hydra/issues/446). + primitiveImplementation :: (Graph -> [Core.Term] -> Either Errors.Error Core.Term)} _Primitive = Core.Name "hydra.graph.Primitive" _Primitive_definition = Core.Name "definition" _Primitive_implementation = Core.Name "implementation" diff --git a/src/main/haskell/Hydra/Json/Bootstrap.hs b/src/main/haskell/Hydra/Json/Bootstrap.hs --- a/src/main/haskell/Hydra/Json/Bootstrap.hs +++ b/src/main/haskell/Hydra/Json/Bootstrap.hs @@ -2142,18 +2142,16 @@ Core.fieldTypeName = (Core.Name "implementation"), Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")), + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}))})), + Core.functionTypeDomain = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))), + Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")), + Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))})), Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [ ( Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "A concrete, host-specific implementation of the primitive function: a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive can return an unreduced applicative term and let the outer reducer fold it. The current carrier still threads `InferenceContext` and `Graph` for historical encode/decode and reducer-callback plumbing; no primitive's compute logic uses them, and they are slated for removal (https://github.com/CategoricalData/hydra/issues/446), sequenced with the `defaultImplementation` integration tracked in https://github.com/CategoricalData/hydra/issues/437.")))]))}))}]), + (Core.TermLiteral (Core.LiteralString "A concrete, host-specific implementation of the primitive function: given the current graph, a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive whose result shape is fixed by its data argument can return an unreduced applicative term and let the outer reducer fold it (no graph needed). The graph is retained for the higher-order primitives that must evaluate a function argument mid-computation (e.g. lists.filter): evaluating that function resolves primitive names against the graph's primitive table. The legacy `InferenceContext` parameter was vestigial and has been removed (https://github.com/CategoricalData/hydra/issues/446).")))]))}))}]), Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [ ( Core.TermVariable (Core.Name "description"), diff --git a/src/main/haskell/Hydra/Lib/Lists.hs b/src/main/haskell/Hydra/Lib/Lists.hs --- a/src/main/haskell/Hydra/Lib/Lists.hs +++ b/src/main/haskell/Hydra/Lib/Lists.hs @@ -26,6 +26,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +import qualified Data.Map as M apply :: Packaging.PrimitiveDefinition apply = Packaging.PrimitiveDefinition { @@ -102,7 +103,36 @@ Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Monadic bind (concatMap) for lists, defined in terms of foldr and concat2.")))]))})))} concat :: Packaging.PrimitiveDefinition concat = Packaging.PrimitiveDefinition { @@ -264,7 +294,24 @@ Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.span")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Drop the leading run satisfying a predicate, defined as the suffix component of span.")))]))})))} elem :: Packaging.PrimitiveDefinition elem = Packaging.PrimitiveDefinition { @@ -334,7 +381,42 @@ Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Filter a list by a predicate, defined in terms of foldr.")))]))})))} find :: Packaging.PrimitiveDefinition find = Packaging.PrimitiveDefinition { @@ -369,7 +451,38 @@ Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermOptional (Just (Core.TermVariable (Core.Name "x"))))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermOptional Nothing)})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Find the first matching element, defined in terms of foldr.")))]))})))} foldl :: Packaging.PrimitiveDefinition foldl = Packaging.PrimitiveDefinition { @@ -864,7 +977,58 @@ Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))}))}))})), + Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Partition a list by a predicate, defined in terms of foldr over a pair of accumulators.")))]))})))} pure :: Packaging.PrimitiveDefinition pure = Packaging.PrimitiveDefinition { @@ -1088,7 +1252,64 @@ Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}))}}, Packaging.primitiveDefinitionIsPure = True, Packaging.primitiveDefinitionIsTotal = True, - Packaging.primitiveDefinitionDefaultImplementation = Nothing} + Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.and")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.null")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermList [], + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))}))}))})), + Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})), + Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ + ( + Core.TermVariable (Core.Name "description"), + (Core.TermLiteral (Core.LiteralString "Split a list at the first predicate failure, defined in terms of foldr over a pair.")))]))})))} take :: Packaging.PrimitiveDefinition take = Packaging.PrimitiveDefinition { diff --git a/src/main/haskell/Hydra/Reduction.hs b/src/main/haskell/Hydra/Reduction.hs --- a/src/main/haskell/Hydra/Reduction.hs +++ b/src/main/haskell/Hydra/Reduction.hs @@ -471,7 +471,7 @@ Core.TermLambda v0 -> reduceLambda v0 _ -> noChange -- | A term evaluation function which is alternatively lazy or eager -reduceTerm :: Typing.InferenceContext -> Graph.Graph -> Bool -> Core.Term -> Either Errors.Error Core.Term +reduceTerm :: t0 -> Graph.Graph -> Bool -> Core.Term -> Either Errors.Error Core.Term reduceTerm cx graph eager term = let reduce = \eager2 -> reduceTerm cx graph eager2 @@ -534,7 +534,7 @@ remainingArgs = Lists.drop arity args2 in (Eithers.bind (Eithers.mapList (reduceArg eager2) argList) (\reducedArgs -> let strippedArgs = Lists.map Strip.deannotateTerm reducedArgs - in (Eithers.bind (Eithers.bimap mapErrorToString (\x -> x) (Graph.primitiveImplementation prim cx graph strippedArgs)) (\primResult -> Eithers.bind (reduce eager2 primResult) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))) + in (Eithers.bind (Eithers.bimap mapErrorToString (\x -> x) (Graph.primitiveImplementation prim graph strippedArgs)) (\primResult -> Eithers.bind (reduce eager2 primResult) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))) in case stripped of Core.TermApplication v0 -> applyIfNullary eager2 (Core.applicationFunction v0) (Lists.cons (Core.applicationArgument v0) args) Core.TermCases v0 -> Logic.ifElse (Lists.null args) (Right original) (forCases v0 args) diff --git a/src/main/haskell/Hydra/Sources/Decode/Ast.hs b/src/main/haskell/Hydra/Sources/Decode/Ast.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Ast.hs +++ /dev/null @@ -1,2441 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.ast - -module Hydra.Sources.Decode.Ast where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.ast"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.ast"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.ast"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.associativity"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Associativity"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "none"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "left"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "right"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "both"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "both"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Associativity")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.blockStyle"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BlockStyle"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.BlockStyle"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "indent"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_indent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineBeforeContent"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_newlineBeforeContent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineAfterContent"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_newlineAfterContent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_indent"))}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineBeforeContent"))}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineAfterContent"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.BlockStyle")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.bracketExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BracketExpr"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.BracketExpr"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "brackets"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.brackets"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_brackets"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "enclosed"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_enclosed"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.blockStyle"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_style"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_brackets"))}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_enclosed"))}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.BracketExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.brackets"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Brackets"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.Brackets"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "open"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_open"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "close"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_close"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_open"))}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_close"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Brackets")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.expr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Expr"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "const"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "const"), - 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.ast.symbol")), - 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 "indent"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "indent"), - 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.ast.indentedExpression")), - 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 "op"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "op"), - 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.ast.opExpr")), - 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 "brackets"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "brackets"), - 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.ast.bracketExpr")), - 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 "seq"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "seq"), - 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.ast.seqExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Expr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.indentStyle"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentStyle"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "allLines"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "allLines"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "subsequentLines"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "subsequentLines"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.IndentStyle")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.indentedExpression"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentedExpression"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.IndentedExpression"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.indentStyle"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_style"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expr"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expr"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expr"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.IndentedExpression")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.op"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Op"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.Op"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_symbol"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "padding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.padding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_padding"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "precedence"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.precedence"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_precedence"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "associativity"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.associativity"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_associativity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_symbol"))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_padding"))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_precedence"))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_associativity"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Op")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.opExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.OpExpr"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.OpExpr"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_op"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lhs"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_lhs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rhs"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_rhs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_lhs"))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_rhs"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.OpExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.padding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Padding"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.Padding"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_right"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - 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.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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Padding")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.precedence"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Precedence"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Precedence")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.seqExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.SeqExpr"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.ast.SeqExpr"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_op"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elements"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_elements"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_elements"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.SeqExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.symbol"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Symbol"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Symbol")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.ws"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Ws"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "none"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "space"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "space"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "break"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "break"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "breakAndIndent"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "breakAndIndent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "doubleBreak"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "doubleBreak"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Ws")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Coders.hs b/src/main/haskell/Hydra/Sources/Decode/Coders.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Coders.hs +++ /dev/null @@ -1,1016 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.coders - -module Hydra.Sources.Decode.Coders where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.coders"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.coders"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.coders"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.errors"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.graph"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.util"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.caseConventions"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.CaseConventions"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.coders.CaseConventions"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constant"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_constant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "directory"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_directory"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "enumValue"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_enumValue"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_field"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "file"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_file"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "module"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_module"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termVariable"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_termVariable"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeVariable"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeVariable"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "constant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_constant"))}, - Core.Field { - Core.fieldName = (Core.Name "directory"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_directory"))}, - Core.Field { - Core.fieldName = (Core.Name "enumValue"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_enumValue"))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))}, - Core.Field { - Core.fieldName = (Core.Name "file"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_file"))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_module"))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}, - Core.Field { - Core.fieldName = (Core.Name "termVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_termVariable"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeVariable"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.CaseConventions")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.coderDirection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "encode"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "decode"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.CoderDirection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.languageFeature"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.LanguageFeature"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "partialApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "partialApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "nestedCaseStatements"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedCaseStatements"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "nestedPolymorphicLetBindings"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedPolymorphicLetBindings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.LanguageFeature")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.languageName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.LanguageName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.traversalOrder"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.TraversalOrder"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "pre"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pre"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "post"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "post"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.TraversalOrder")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Core.hs b/src/main/haskell/Hydra/Sources/Decode/Core.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Core.hs +++ /dev/null @@ -1,6527 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.core - -module Hydra.Sources.Decode.Core where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.core"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.annotatedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.AnnotatedTerm"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_annotation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.AnnotatedTerm")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.annotatedType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.AnnotatedType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_annotation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.AnnotatedType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.application"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Application"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Application"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_function"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_argument"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Application")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.applicationType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.ApplicationType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_function"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_argument"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.ApplicationType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.binding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Binding"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Binding"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeScheme"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeScheme"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}, - Core.Field { - Core.fieldName = (Core.Name "typeScheme"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeScheme"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Binding")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.caseAlternative"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.CaseAlternative"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.CaseAlternative"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "handler"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_handler"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "handler"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_handler"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.CaseAlternative")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.caseStatement"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.CaseStatement"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "default"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_default"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cases"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.caseAlternative"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_default"))}, - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.CaseStatement")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.eitherType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.EitherType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.EitherType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_right"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - 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.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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.EitherType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.field"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Field"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Field"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.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.TermLambda (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.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Field")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.fieldType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FieldType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.FieldType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FieldType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.floatType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "float32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "float64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FloatType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.floatValue"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatValue"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "float32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 float32 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float32 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "float64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 float64 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float64 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FloatValue")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.forallType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ForallType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.ForallType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.ForallType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.functionType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FunctionType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.FunctionType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "codomain"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_codomain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_codomain"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FunctionType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.injection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Injection"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Injection"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_field"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Injection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.integerType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "bigint"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "int8"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "int16"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "int32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "int64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "uint8"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "uint16"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "uint32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "uint64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.IntegerType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.integerValue"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "bigint"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 bigint literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 bigint value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "bigint"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "int8"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 int8 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 int8 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int8"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "int16"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 int16 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 int16 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int16"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "int32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "int64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 int64 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 int64 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int64"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "uint8"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 uint8 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 uint8 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint8"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "uint16"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 uint16 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 uint16 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint16"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "uint32"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 uint32 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 uint32 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "uint64"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 uint64 literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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 uint64 value"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint64"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.IntegerValue")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.lambda"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Lambda"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Lambda"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Lambda")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.let"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Let"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Let"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Let")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.literal"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Literal"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "binary"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 binary literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "binary"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "boolean"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "decimal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decimal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 decimal literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "d"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d"))))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "float"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - 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.core.floatValue")), - 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 "integer"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - 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.core.integerValue")), - 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 "string"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Literal")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.literalType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.LiteralType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "binary"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "boolean"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "decimal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decimal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "float"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - 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.core.floatType")), - 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 "integer"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - 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.core.integerType")), - 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 "string"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.LiteralType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.mapType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.MapType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.MapType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keys"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_keys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "values"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_values"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_keys"))}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_values"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.MapType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.name"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Name"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Name")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.pairType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.PairType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.PairType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_first"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_second"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.PairType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.projection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Projection"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Projection"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Projection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.record"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Record"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.Record"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fields"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fields"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fields"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Record")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.term"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotated"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - 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.core.annotatedTerm")), - 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 "application"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - 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.core.application")), - 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 "cases"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "cases"), - 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.core.caseStatement")), - 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 "either"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - 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.core.decodeEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "inject"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - 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.core.injection")), - 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 "lambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - 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.core.lambda")), - 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 "let"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - 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.core.let")), - 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 "list"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "literal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - 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.core.literal")), - 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 "map"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - 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.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "optional"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "pair"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - 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.core.decodePair")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "project"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "project"), - 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.core.projection")), - 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 "record"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - 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.core.record")), - 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 "set"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - 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 "typeApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - 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.core.typeApplicationTerm")), - 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 "typeLambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - 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.core.typeLambda")), - 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 "unit"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unwrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unwrap"), - 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.core.name")), - 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 "variable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - 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.core.name")), - 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 "wrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - 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.core.wrappedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Term")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.type"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Type"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotated"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - 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.core.annotatedType")), - 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 "application"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - 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.core.applicationType")), - 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 "either"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - 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.core.eitherType")), - 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 "forall"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - 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.core.forallType")), - 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 "function"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - 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.core.functionType")), - 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 "list"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - 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.core.type")), - 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 "literal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - 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.core.literalType")), - 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 "map"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - 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.core.mapType")), - 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 "optional"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - 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.core.type")), - 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 "pair"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - 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.core.pairType")), - 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 "record"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})), - 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 "set"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - 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.core.type")), - 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 "union"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})), - 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 "unit"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "variable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - 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.core.name")), - 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 "void"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "wrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - 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.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Type")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeApplicationTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.TypeApplicationTerm"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeApplicationTerm")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeClassConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "simple"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.TypeClassConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "simple"), - 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.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeClassConstraint")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeLambda"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.TypeLambda"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeLambda")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeScheme"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.TypeScheme"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variables"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constraints"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeVariableConstraints"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_constraints"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_constraints"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeScheme")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeVariableConstraints"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.TypeVariableConstraints"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "classes"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeClassConstraint"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_classes"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "classes"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_classes"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeVariableConstraints")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.core.wrappedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.core.WrappedTerm"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.WrappedTerm")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs +++ /dev/null @@ -1,2013 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.error.checking - -module Hydra.Sources.Decode.Error.Checking where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.checking"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.checking"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.checking"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.checkingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "incorrectUnification"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "incorrectUnification"), - 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.error.checking.incorrectUnificationError")), - 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 "notAForallType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAForallType"), - 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.error.checking.notAForallTypeError")), - 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 "notAFunctionType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAFunctionType"), - 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.error.checking.notAFunctionTypeError")), - 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 "other"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - 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.error.checking.otherCheckingError")), - 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 "typeArityMismatch"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeArityMismatch"), - 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.error.checking.typeArityMismatchError")), - 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 "typeMismatch"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeMismatch"), - 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.error.checking.typeMismatchError")), - 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 "unboundTypeVariables"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unboundTypeVariables"), - 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.error.checking.unboundTypeVariablesError")), - 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 "undefinedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - 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.error.checking.undefinedTermVariableCheckingError")), - 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 "unequalTypes"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unequalTypes"), - 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.error.checking.unequalTypesError")), - 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 "unsupportedTermVariant"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unsupportedTermVariant"), - 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.error.checking.unsupportedTermVariantError")), - 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 "untypedLambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLambda"), - 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.error.checking.untypedLambdaError")), - 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 "untypedLetBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLetBinding"), - 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.error.checking.untypedLetBindingError")), - 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 "untypedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - 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.error.checking.untypedTermVariableCheckingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.CheckingError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.incorrectUnificationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.IncorrectUnificationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.IncorrectUnificationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "substitution"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_substitution"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_substitution"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.IncorrectUnificationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAForallTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAForallTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.NotAForallTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeArguments"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.NotAForallTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAFunctionTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAFunctionTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.NotAFunctionTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.NotAFunctionTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.otherCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.OtherCheckingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.OtherCheckingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_message"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.OtherCheckingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeArityMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeArityMismatchError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.TypeArityMismatchError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedArity"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedArity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualArity"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualArity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeArguments"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedArity"))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualArity"))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.TypeArityMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeMismatchError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.TypeMismatchError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedType"))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.TypeMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unboundTypeVariablesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnboundTypeVariablesError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UnboundTypeVariablesError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variables"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnboundTypeVariablesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.undefinedTermVariableCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UndefinedTermVariableCheckingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UndefinedTermVariableCheckingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unequalTypesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnequalTypesError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UnequalTypesError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "types"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_types"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_description"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_types"))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnequalTypesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unsupportedTermVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnsupportedTermVariantError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UnsupportedTermVariantError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_termVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "termVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_termVariant"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnsupportedTermVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLambdaError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLambdaError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UntypedLambdaError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), - Core.recordFields = []}))))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedLambdaError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLetBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLetBindingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UntypedLetBindingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_binding"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "binding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_binding"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedLetBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedTermVariableCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.checking.UntypedTermVariableCheckingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedTermVariableCheckingError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs +++ /dev/null @@ -1,5438 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.error.core - -module Hydra.Sources.Decode.Error.Core where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.core"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.core"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.constantConditionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.ConstantConditionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.ConstantConditionError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "value"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_value"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_value"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.ConstantConditionError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.DuplicateBindingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.DuplicateFieldError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateRecordTypeFieldNamesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateRecordTypeFieldNamesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateUnionTypeFieldNamesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateUnionTypeFieldNamesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyCaseStatementError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyCaseStatementError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyCaseStatementError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyCaseStatementError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyLetBindingsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyLetBindingsError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyLetBindingsError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyLetBindingsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyRecordTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyRecordTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyRecordTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyRecordTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTermAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTermAnnotationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyTermAnnotationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTermAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeAnnotationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyTypeAnnotationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTypeAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeNameInTermError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeNameInTermError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyTypeNameInTermError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTypeNameInTermError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyUnionTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyUnionTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.EmptyUnionTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyUnionTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidForallParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidForallParameterNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.InvalidForallParameterNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidForallParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLambdaParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.InvalidLambdaParameterNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLambdaParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLetBindingNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLetBindingNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.InvalidLetBindingNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLetBindingNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLiteralError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLiteralError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "typeMismatch"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeMismatch"), - 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.error.core.literalTypeMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLiteralError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTermError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTermError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "constantCondition"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "constantCondition"), - 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.error.core.constantConditionError")), - 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 "duplicateBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - 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.error.core.duplicateBindingError")), - 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 "duplicateField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - 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.error.core.duplicateFieldError")), - 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 "emptyCaseStatement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyCaseStatement"), - 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.error.core.emptyCaseStatementError")), - 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 "emptyLetBindings"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyLetBindings"), - 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.error.core.emptyLetBindingsError")), - 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 "emptyTermAnnotation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - 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.error.core.emptyTermAnnotationError")), - 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 "emptyTypeNameInTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeNameInTerm"), - 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.error.core.emptyTypeNameInTermError")), - 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 "invalidLambdaParameterName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLambdaParameterName"), - 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.error.core.invalidLambdaParameterNameError")), - 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 "invalidLetBindingName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLetBindingName"), - 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.error.core.invalidLetBindingNameError")), - 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 "invalidTypeLambdaParameterName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"), - 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.error.core.invalidTypeLambdaParameterNameError")), - 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 "nestedTermAnnotation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTermAnnotation"), - 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.error.core.nestedTermAnnotationError")), - 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 "redundantWrapUnwrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "redundantWrapUnwrap"), - 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.error.core.redundantWrapUnwrapError")), - 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 "selfApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "selfApplication"), - 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.error.core.selfApplicationError")), - 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 "termVariableShadowing"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "termVariableShadowing"), - 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.error.core.termVariableShadowingError")), - 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 "typeVariableShadowingInTypeLambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"), - 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.error.core.typeVariableShadowingInTypeLambdaError")), - 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 "undefinedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - 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.error.core.undefinedTermVariableError")), - 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 "undefinedTypeVariableInBindingType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"), - 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.error.core.undefinedTypeVariableInBindingTypeError")), - 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 "undefinedTypeVariableInLambdaDomain"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"), - 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.error.core.undefinedTypeVariableInLambdaDomainError")), - 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 "undefinedTypeVariableInTypeApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"), - 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.error.core.undefinedTypeVariableInTypeApplicationError")), - 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 "unknownPrimitiveName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unknownPrimitiveName"), - 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.error.core.unknownPrimitiveNameError")), - 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 "unnecessaryIdentityApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unnecessaryIdentityApplication"), - 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.error.core.unnecessaryIdentityApplicationError")), - 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 "untypedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - 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.error.core.untypedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTermError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "duplicateRecordTypeFieldNames"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"), - 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.error.core.duplicateRecordTypeFieldNamesError")), - 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 "duplicateUnionTypeFieldNames"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"), - 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.error.core.duplicateUnionTypeFieldNamesError")), - 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 "emptyRecordType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyRecordType"), - 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.error.core.emptyRecordTypeError")), - 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 "emptyTypeAnnotation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeAnnotation"), - 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.error.core.emptyTypeAnnotationError")), - 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 "emptyUnionType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyUnionType"), - 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.error.core.emptyUnionTypeError")), - 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 "invalidForallParameterName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidForallParameterName"), - 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.error.core.invalidForallParameterNameError")), - 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 "invalidTypeSchemeVariableName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"), - 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.error.core.invalidTypeSchemeVariableNameError")), - 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 "nestedTypeAnnotation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTypeAnnotation"), - 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.error.core.nestedTypeAnnotationError")), - 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 "nonComparableMapKeyType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableMapKeyType"), - 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.error.core.nonComparableMapKeyTypeError")), - 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 "nonComparableSetElementType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableSetElementType"), - 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.error.core.nonComparableSetElementTypeError")), - 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 "singleVariantUnion"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - 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.error.core.singleVariantUnionError")), - 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 "typeVariableShadowingInForall"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInForall"), - 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.error.core.typeVariableShadowingInForallError")), - 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 "undefinedTypeVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariable"), - 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.error.core.undefinedTypeVariableError")), - 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 "voidInNonBottomPosition"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "voidInNonBottomPosition"), - 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.error.core.voidInNonBottomPositionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeLambdaParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.InvalidTypeLambdaParameterNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeLambdaParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeSchemeVariableNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.InvalidTypeSchemeVariableNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeSchemeVariableNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.literalTypeMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.LiteralTypeMismatchError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.LiteralTypeMismatchError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.literalType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.literalType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedType"))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.LiteralTypeMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTermAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTermAnnotationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.NestedTermAnnotationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NestedTermAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTypeAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTypeAnnotationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.NestedTypeAnnotationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NestedTypeAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableMapKeyTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.NonComparableMapKeyTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keyType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_keyType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_keyType"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NonComparableMapKeyTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableSetElementTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableSetElementTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.NonComparableSetElementTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elementType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_elementType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_elementType"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NonComparableSetElementTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.redundantWrapUnwrapError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.RedundantWrapUnwrapError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.RedundantWrapUnwrapError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.RedundantWrapUnwrapError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.selfApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SelfApplicationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.SelfApplicationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.SelfApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.singleVariantUnionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SingleVariantUnionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.SingleVariantUnionError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.SingleVariantUnionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.termVariableShadowingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TermVariableShadowingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.TermVariableShadowingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TermVariableShadowingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInForallError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.TypeVariableShadowingInForallError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TypeVariableShadowingInForallError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInTypeLambdaError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedFieldError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTermVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedTermVariableError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTermVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedTypeVariableError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInBindingTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInLambdaDomainError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInTypeApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTermVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UnexpectedTermVariantError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualTerm"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualTerm"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnexpectedTermVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTypeVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UnexpectedTypeVariantError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.typeVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnexpectedTypeVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unknownPrimitiveNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnknownPrimitiveNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UnknownPrimitiveNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnknownPrimitiveNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unnecessaryIdentityApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UnnecessaryIdentityApplicationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnnecessaryIdentityApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.untypedTermVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.UntypedTermVariableError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UntypedTermVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.voidInNonBottomPositionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.VoidInNonBottomPositionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.core.VoidInNonBottomPositionError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.VoidInNonBottomPositionError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs +++ /dev/null @@ -1,1632 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.error.packaging - -module Hydra.Sources.Decode.Error.Packaging where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.packaging"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.packaging"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.packaging"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.packaging"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.util"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingModuleNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.ConflictingModuleNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_first"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_second"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.ConflictingModuleNameError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingVariantNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingVariantNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.ConflictingVariantNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variantName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variantName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "conflictingName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_conflictingName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variantName"))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_conflictingName"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.ConflictingVariantNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.definitionNotInModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.DefinitionNotInModuleNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DefinitionNotInModuleNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.definitionsOutOfOrderError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.DefinitionsOutOfOrderError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "precedingName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_precedingName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "followingName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_followingName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "precedingName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_precedingName"))}, - Core.Field { - Core.fieldName = (Core.Name "followingName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_followingName"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DefinitionsOutOfOrderError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateDefinitionNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.DuplicateDefinitionNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DuplicateDefinitionNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateModuleNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.DuplicateModuleNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DuplicateModuleNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidDefinitionNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.InvalidDefinitionNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedConvention"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedConvention"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "expectedConvention"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedConvention"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidDefinitionNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidModuleError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "conflictingVariantName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - 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.error.packaging.conflictingVariantNameError")), - 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 "definitionNotInModuleName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "definitionNotInModuleName"), - 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.error.packaging.definitionNotInModuleNameError")), - 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 "definitionsOutOfOrder"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "definitionsOutOfOrder"), - 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.error.packaging.definitionsOutOfOrderError")), - 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 "duplicateDefinitionName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateDefinitionName"), - 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.error.packaging.duplicateDefinitionNameError")), - 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 "invalidDefinitionName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidDefinitionName"), - 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.error.packaging.invalidDefinitionNameError")), - 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 "invalidModuleNameConvention"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidModuleNameConvention"), - 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.error.packaging.invalidModuleNameConventionError")), - 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 "missingDocumentation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "missingDocumentation"), - 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.error.packaging.missingDocumentationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidModuleError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidModuleNameConventionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.InvalidModuleNameConventionError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidModuleNameConventionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidPackageError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "conflictingModuleName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingModuleName"), - 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.error.packaging.conflictingModuleNameError")), - 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 "duplicateModuleName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateModuleName"), - 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.error.packaging.duplicateModuleNameError")), - 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 "invalidModule"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidModule"), - 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.error.packaging.invalidModuleError")), - 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 "invalidPackageName"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidPackageName"), - 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.error.packaging.invalidPackageNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidPackageError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidPackageNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageNameError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.InvalidPackageNameError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "packageName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_packageName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "packageName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_packageName"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidPackageNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.missingDocumentationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.MissingDocumentationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.error.packaging.MissingDocumentationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.MissingDocumentationError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Errors.hs b/src/main/haskell/Hydra/Sources/Decode/Errors.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Errors.hs +++ /dev/null @@ -1,2759 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.errors - -module Hydra.Sources.Decode.Errors where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.errors"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.errors"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.errors"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.checking"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.decodingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.DecodingError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.emptyListError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = Core.TypeUnit}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.EmptyListError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.error"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.Error"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "checking"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "checking"), - 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.error.checking.checkingError")), - 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 "decoding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decoding"), - 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.errors.decodingError")), - 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 "duplicateBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - 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.error.core.duplicateBindingError")), - 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 "duplicateField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - 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.error.core.duplicateFieldError")), - 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 "extraction"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "extraction"), - 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.errors.extractionError")), - 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.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - 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.errors.inferenceError")), - 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 "invalidLiteral"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLiteral"), - 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.error.core.invalidLiteralError")), - 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 "other"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - 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.errors.otherError")), - 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 "resolution"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "resolution"), - 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.errors.resolutionError")), - 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 "undefinedField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedField"), - 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.error.core.undefinedFieldError")), - 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 "undefinedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - 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.error.core.undefinedTermVariableError")), - 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 "untypedTermVariable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - 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.error.core.untypedTermVariableError")), - 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 "unexpectedTermVariant"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTermVariant"), - 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.error.core.unexpectedTermVariantError")), - 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 "unexpectedTypeVariant"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTypeVariant"), - 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.error.core.unexpectedTypeVariantError")), - 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 "unification"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unification"), - 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.errors.unificationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.Error")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.extractionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.ExtractionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "emptyList"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyList"), - 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.errors.emptyListError")), - 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 "multipleBindings"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "multipleBindings"), - 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.errors.multipleBindingsError")), - 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 "multipleFields"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "multipleFields"), - 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.errors.multipleFieldsError")), - 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 "noMatchingField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "noMatchingField"), - 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.errors.noMatchingFieldError")), - 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 "noSuchBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "noSuchBinding"), - 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.errors.noSuchBindingError")), - 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 "notEnoughCases"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notEnoughCases"), - 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.errors.notEnoughCasesError")), - 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 "unexpectedShape"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedShape"), - 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.errors.unexpectedShapeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.ExtractionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.inferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.InferenceError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "checking"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "checking"), - 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.error.checking.checkingError")), - 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 "other"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - 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.errors.otherInferenceError")), - 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 "unification"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unification"), - 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.errors.unificationInferenceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.InferenceError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.multipleBindingsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.MultipleBindingsError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.MultipleBindingsError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.MultipleBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.MultipleBindingsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.multipleFieldsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.MultipleFieldsError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.MultipleFieldsError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.MultipleFieldsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.MultipleFieldsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noMatchingFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.NoMatchingFieldError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoMatchingFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noSuchBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.NoSuchBindingError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.NoSuchBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoSuchBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noSuchPrimitiveError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchPrimitiveError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.NoSuchPrimitiveError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoSuchPrimitiveError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.notEnoughCasesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = Core.TypeUnit}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NotEnoughCasesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherInferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherInferenceError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.OtherInferenceError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_message"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherInferenceError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherResolutionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherResolutionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherResolutionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.resolutionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.ResolutionError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "noSuchBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "noSuchBinding"), - 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.errors.noSuchBindingError")), - 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 "noSuchPrimitive"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "noSuchPrimitive"), - 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.errors.noSuchPrimitiveError")), - 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 "noMatchingField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "noMatchingField"), - 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.errors.noMatchingFieldError")), - 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 "other"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - 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.errors.otherResolutionError")), - 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 "unexpectedShape"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedShape"), - 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.errors.unexpectedShapeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.ResolutionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unexpectedShapeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.UnexpectedShapeError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expected"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actual"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actual"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))}, - Core.Field { - Core.fieldName = (Core.Name "actual"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actual"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnexpectedShapeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unificationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.UnificationError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "leftType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_leftType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rightType"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_rightType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_message"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_leftType"))}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_rightType"))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnificationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unificationInferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnificationInferenceError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.errors.UnificationInferenceError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cause"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.errors.unificationError"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_cause"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "cause"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_cause"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnificationInferenceError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs b/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs +++ /dev/null @@ -1,503 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.json.model - -module Hydra.Sources.Decode.Json.Model where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.json.model"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.json.model"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.json.model"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.json.model.value"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.json.model.Value"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "array"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "array"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})), - 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 "boolean"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "null"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "number"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "number"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 decimal literal"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "d"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d"))))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "object"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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 "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 "string"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.json.model.Value")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Packaging.hs b/src/main/haskell/Hydra/Sources/Decode/Packaging.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Packaging.hs +++ /dev/null @@ -1,2563 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.packaging - -module Hydra.Sources.Decode.Packaging where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.packaging"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.packaging"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.packaging"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.definition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Definition"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "term"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - 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.packaging.termDefinition")), - 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 "type"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - 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.packaging.typeDefinition")), - 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 "primitive"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - 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.packaging.primitiveDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Definition")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.definitionReference"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.DefinitionReference"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "type"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - 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.core.name")), - 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 "term"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - 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.core.name")), - 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 "primitive"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - 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.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.DefinitionReference")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.entityMetadata"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.EntityMetadata"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "comments"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_comments"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "seeAlso"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityReference"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_seeAlso"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lifecycle"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.lifecycleInfo"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_lifecycle"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_comments"))}, - Core.Field { - Core.fieldName = (Core.Name "seeAlso"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_seeAlso"))}, - Core.Field { - Core.fieldName = (Core.Name "lifecycle"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_lifecycle"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.EntityMetadata")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.entityReference"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.EntityReference"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "package"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "package"), - 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.packaging.packageName")), - 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 "module"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "module"), - 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.packaging.moduleName")), - 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 "definition"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "definition"), - 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.packaging.definitionReference")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.EntityReference")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.lifecycleInfo"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.LifecycleInfo"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.LifecycleInfo"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "availableSince"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.version"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_availableSince"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "deprecatedSince"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.version"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_deprecatedSince"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "availableSince"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_availableSince"))}, - Core.Field { - Core.fieldName = (Core.Name "deprecatedSince"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_deprecatedSince"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.LifecycleInfo")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.module"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Module"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.Module"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_metadata"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "dependencies"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleDependency"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_dependencies"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "definitions"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.definition"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_definitions"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_dependencies"))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_definitions"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Module")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.moduleDependency"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleDependency"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.ModuleDependency"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "module"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_module"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "package"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_package"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_module"))}, - Core.Field { - Core.fieldName = (Core.Name "package"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_package"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.ModuleDependency")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.moduleName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.ModuleName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.package"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Package"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.Package"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_metadata"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "dependencies"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageDependency"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_dependencies"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "modules"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.module"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_modules"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_dependencies"))}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_modules"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Package")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.packageDependency"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PackageDependency"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.PackageDependency"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "version"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.versionSpecifier"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_version"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "version"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_version"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PackageDependency")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.packageName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PackageName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.primitiveDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.PrimitiveDefinition"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_metadata"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "signature"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.termSignature"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_signature"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isPure"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_isPure"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isTotal"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_isTotal"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "defaultImplementation"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_defaultImplementation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))}, - Core.Field { - Core.fieldName = (Core.Name "signature"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_signature"))}, - Core.Field { - Core.fieldName = (Core.Name "isPure"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_isPure"))}, - Core.Field { - Core.fieldName = (Core.Name "isTotal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_isTotal"))}, - Core.Field { - Core.fieldName = (Core.Name "defaultImplementation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_defaultImplementation"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PrimitiveDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.termDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.TermDefinition"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.TermDefinition"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_metadata"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "signature"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.termSignature"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_signature"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))}, - Core.Field { - Core.fieldName = (Core.Name "signature"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_signature"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.TermDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.typeDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.TypeDefinition"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.packaging.TypeDefinition"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_metadata"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.TypeDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.version"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Version"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.packaging.Version"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Version")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.versionSpecifier"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.VersionSpecifier"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "any"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.packaging.VersionSpecifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "any"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.VersionSpecifier")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Parsing.hs b/src/main/haskell/Hydra/Sources/Decode/Parsing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Parsing.hs +++ /dev/null @@ -1,599 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.parsing - -module Hydra.Sources.Decode.Parsing where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.parsing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.parsing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.parsing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.parsing.ParseError"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.parsing.ParseError"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_message"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "remainder"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_remainder"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_remainder"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.parsing.ParseResult")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "success"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "success"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseSuccess")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - 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 "failure"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "failure"), - 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.parsing.parseError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseResult")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseSuccess"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.parsing.ParseSuccess")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.parsing.ParseSuccess"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "value"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_value"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "remainder"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_remainder"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_value"))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_remainder"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseSuccess")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Paths.hs b/src/main/haskell/Hydra/Sources/Decode/Paths.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Paths.hs +++ /dev/null @@ -1,2771 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.paths - -module Hydra.Sources.Decode.Paths where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.paths"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.paths"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermEdge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermEdge"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtermEdge"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "source"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_source"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "target"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_target"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_source"))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_target"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermEdge")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermGraph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermGraph"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtermGraph"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "nodes"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_nodes"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "edges"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermEdge"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_edges"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_nodes"))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_edges"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermGraph")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermNode"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermNode"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtermNode"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "label"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_label"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "id"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_id"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_label"))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_id"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermNode")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermPath"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermStep"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermPath")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermStep"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermStep"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotatedBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "applicationFunction"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "applicationArgument"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "lambdaBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambdaBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unionCasesDefault"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesDefault"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unionCasesBranch"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesBranch"), - 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.core.name")), - 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 "letBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "letBinding"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBinding"), - 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.core.name")), - 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 "listElement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "mapKey"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKey"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "mapValue"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValue"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "optionalTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optionalTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "productTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "productTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "recordField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - 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.core.name")), - 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 "setElement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "sumTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sumTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "typeLambdaBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambdaBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "typeApplicationTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplicationTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "injectionTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "injectionTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "wrappedTerm"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermStep")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeEdge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeEdge"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtypeEdge"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "source"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_source"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypePath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "target"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_target"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_source"))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_target"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeEdge")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeGraph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeGraph"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtypeGraph"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "nodes"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_nodes"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "edges"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeEdge"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_edges"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_nodes"))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_edges"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeGraph")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeNode"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeNode"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.paths.SubtypeNode"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "label"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_label"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "id"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_id"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_label"))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_id"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeNode")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypePath"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypePath"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeStep"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypePath")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeStep"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeStep"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotatedBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "applicationFunction"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "applicationArgument"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "eitherLeft"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherLeft"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "eitherRight"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherRight"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "forallBody"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forallBody"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "functionDomain"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionDomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "functionCodomain"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionCodomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "listElement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "mapKeys"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKeys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "mapValues"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValues"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "optionalElement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optionalElement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "pairFirst"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairFirst"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "pairSecond"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairSecond"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "recordField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - 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.core.name")), - 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 "setElement"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unionField"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionField"), - 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.core.name")), - 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 "wrappedType"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeStep")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Query.hs b/src/main/haskell/Hydra/Sources/Decode/Query.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Query.hs +++ /dev/null @@ -1,2719 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.query - -module Hydra.Sources.Decode.Query where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.query"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.query"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.query"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.comparisonConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.ComparisonConstraint"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "equal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "notEqual"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notEqual"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "lessThan"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "greaterThan"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "lessThanOrEqual"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThanOrEqual"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "greaterThanOrEqual"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThanOrEqual"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.ComparisonConstraint")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.edge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Edge"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.Edge"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "out"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_out"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "in"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_in"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_out"))}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_in"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Edge")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.graphPattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.GraphPattern"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.GraphPattern"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "graph"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_graph"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "patterns"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_patterns"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_graph"))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_patterns"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.GraphPattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.node"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Node"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "term"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - 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.core.term")), - 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 "variable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - 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.query.variable")), - 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 "wildcard"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wildcard"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Node")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.path"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Path"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "step"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "step"), - 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.query.step")), - 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 "regex"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "regex"), - 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.query.regexSequence")), - 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 "inverse"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inverse"), - 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.query.path")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Path")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.pathEquation"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.PathEquation"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.PathEquation"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_right"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PathEquation"), - 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.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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.PathEquation")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.pattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Pattern"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "triple"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "triple"), - 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.query.triplePattern")), - 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 "negation"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "negation"), - 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.query.pattern")), - 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 "conjunction"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conjunction"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})), - 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 "disjunction"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "disjunction"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})), - 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 "graph"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "graph"), - 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.query.graphPattern")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Pattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.patternImplication"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.PatternImplication"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.PatternImplication"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "antecedent"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_antecedent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "consequent"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_consequent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "antecedent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_antecedent"))}, - Core.Field { - Core.fieldName = (Core.Name "consequent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_consequent"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.PatternImplication")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.query"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Query"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.Query"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.variable"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variables"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "patterns"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_patterns"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Query"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_patterns"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Query")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.range"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Range"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.Range"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "min"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_min"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "max"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_max"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Range"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "min"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_min"))}, - Core.Field { - Core.fieldName = (Core.Name "max"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_max"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Range")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.regexQuantifier"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.RegexQuantifier"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "one"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "one"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "zeroOrOne"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrOne"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "zeroOrMore"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrMore"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "oneOrMore"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "oneOrMore"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "exactly"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "exactly"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "atLeast"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "atLeast"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - 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 "range"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "range"), - 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.query.range")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.RegexQuantifier")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.regexSequence"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.RegexSequence"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.RegexSequence"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_path"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "quantifier"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.regexQuantifier"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_quantifier"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))}, - Core.Field { - Core.fieldName = (Core.Name "quantifier"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_quantifier"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.RegexSequence")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.step"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Step"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "edge"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "edge"), - 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.query.edge")), - 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 "project"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "project"), - 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.core.projection")), - 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 "compare"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "compare"), - 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.query.comparisonConstraint")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Step")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.triplePattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.TriplePattern"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.query.TriplePattern"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "subject"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.node"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_subject"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "predicate"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "object"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.node"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_object"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_subject"))}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_predicate"))}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_object"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.TriplePattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.query.variable"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Variable"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Variable")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Relational.hs b/src/main/haskell/Hydra/Sources/Decode/Relational.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Relational.hs +++ /dev/null @@ -1,1087 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.relational - -module Hydra.Sources.Decode.Relational where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.relational"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.relational"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.relational"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.columnName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.ColumnName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ColumnName")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.columnSchema"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "t"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "t"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.relational.ColumnSchema")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.relational.ColumnSchema"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ColumnSchema")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.foreignKey"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.ForeignKey"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.relational.ForeignKey"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foreignRelation"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_foreignRelation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keys"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_keys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "foreignRelation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_foreignRelation"))}, - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_keys"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ForeignKey")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.primaryKey"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.PrimaryKey"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.PrimaryKey")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relation"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "v"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.relational.Relation")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.row")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Relation")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.RelationName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.RelationName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationSchema"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "t"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "t"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.relational.RelationSchema")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.relational.RelationSchema"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "columns"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.columnSchema")), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_columns"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "primaryKeys"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.primaryKey"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_primaryKeys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foreignKeys"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.foreignKey"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_foreignKeys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_columns"))}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_primaryKeys"))}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_foreignKeys"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.RelationSchema")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationship"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = [ - Core.TypeClassConstraintSimple (Core.Name "ordering")]}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "v"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.relational.Relationship")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Relationship")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.row"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "v"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.relational.Row")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Row")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Tabular.hs b/src/main/haskell/Hydra/Sources/Decode/Tabular.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Tabular.hs +++ /dev/null @@ -1,614 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.tabular - -module Hydra.Sources.Decode.Tabular where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.tabular"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.tabular"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.tabular"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.relational"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.columnType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.ColumnType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.tabular.ColumnType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.ColumnType")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.dataRow"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "v"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.tabular.DataRow")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.DataRow")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.headerRow"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.HeaderRow"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.HeaderRow")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.table"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "v"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.tabular.Table")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.tabular.Table"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "header"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.tabular.headerRow"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_header"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "data"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.tabular.dataRow")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_data"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.Table"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "header"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_header"))}, - Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_data"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.Table")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.tableType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.TableType"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.tabular.TableType"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "columns"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.tabular.columnType"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_columns"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.TableType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_columns"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.TableType")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Testing.hs b/src/main/haskell/Hydra/Sources/Decode/Testing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Testing.hs +++ /dev/null @@ -1,164 +0,0 @@ --- 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.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.testing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.testing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.testing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.testing.tag"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.Tag"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.testing.Tag")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Topology.hs b/src/main/haskell/Hydra/Sources/Decode/Topology.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Topology.hs +++ /dev/null @@ -1,517 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.topology - -module Hydra.Sources.Decode.Topology where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.topology"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.topology"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.topology"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.graph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.topology.Vertex")), - Core.mapTypeValues = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.topology.Vertex")))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.Graph")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.tarjanState"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.topology.TarjanState"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.topology.TarjanState"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "counter"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_counter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "indices"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_indices"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lowLinks"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_lowLinks"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "stack"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_stack"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "onStack"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_onStack"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "sccs"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_sccs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_counter"))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_indices"))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_lowLinks"))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_stack"))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_onStack"))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_sccs"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.TarjanState")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.vertex"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Literal"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.Vertex")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Typed.hs b/src/main/haskell/Hydra/Sources/Decode/Typed.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Typed.hs +++ /dev/null @@ -1,391 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.typed - -module Hydra.Sources.Decode.Typed where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.typed"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.typed"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typed"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedBinding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.typed.TypedBinding")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typed.TypedBinding"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.typed.typedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.typed.TypedBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedBinding")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.typed.TypedTerm")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.term")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedTerm")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedTermDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.typed.TypedTermDefinition")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typed.TypedTermDefinition"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.typed.typedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.typed.TypedTermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedTermDefinition")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Typing.hs b/src/main/haskell/Hydra/Sources/Decode/Typing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Typing.hs +++ /dev/null @@ -1,1709 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.typing - -module Hydra.Sources.Decode.Typing where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.typing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.typing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.functionStructure"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "env"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "env"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.typing.FunctionStructure")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "env"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "env"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.FunctionStructure"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeParams"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeParams"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "params"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_params"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domains"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domains"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "codomain"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_codomain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "environment"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "env"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_environment"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeParams"))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_params"))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domains"))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_codomain"))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_environment"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.FunctionStructure")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.inferenceContext"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.InferenceContext"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "freshTypeVariableCount"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_freshTypeVariableCount"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "trace"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermStep"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_trace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "freshTypeVariableCount"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_freshTypeVariableCount"))}, - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_trace"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.InferenceContext")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.inferenceResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.InferenceResult"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.InferenceResult"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "subst"))})), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_subst"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "classConstraints"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeVariableConstraints"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_classConstraints"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "context"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.inferenceContext"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_context"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_subst"))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_classConstraints"))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_context"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.InferenceResult")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.parameter"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.Parameter"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.Parameter"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (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.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isLazy"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_isLazy"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.Parameter"), - 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 "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "isLazy"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_isLazy"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.Parameter")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.result"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.Result"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.Result"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (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.TermVariable (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.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.Result"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.Result")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.termSignature"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TermSignature"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.TermSignature"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeParameters"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeParameter"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeParameters"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameters"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.parameter"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameters"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "result"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.result"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (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.typing.TermSignature"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParameters"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeParameters"))}, - Core.Field { - Core.fieldName = (Core.Name "parameters"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameters"))}, - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TermSignature")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.termSubst"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TermSubst"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - 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.core.decodeMap")), - 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 "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TermSubst")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeClass"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeClass"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.TypeClass"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_description"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeClass")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeConstraint"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.TypeConstraint"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "comment"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_comment"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - 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 "comment"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_comment"))}]}))))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeConstraint")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeParameter"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeParameter"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.typing.TypeParameter"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - 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.TermLambda (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.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constraints"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeClassConstraint"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_constraints"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_constraints"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeParameter")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeSubst"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeSubst"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - 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.core.decodeMap")), - 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 "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeSubst")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Util.hs b/src/main/haskell/Hydra/Sources/Decode/Util.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Util.hs +++ /dev/null @@ -1,1147 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.util - -module Hydra.Sources.Decode.Util where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.util"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.util"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.packaging"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.caseConvention"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "camel"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "camel"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "pascal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pascal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "lowerSnake"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lowerSnake"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "upperSnake"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "upperSnake"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.CaseConvention")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.comparison"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.Comparison"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "lessThan"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "equalTo"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equalTo"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "greaterThan"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.Comparison")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.fileExtension"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.FileExtension"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.util.FileExtension"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.FileExtension")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.moduleNames"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "n"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "n"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.util.ModuleNames")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "n"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "n"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.util.ModuleNames"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "focus"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "n"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_focus"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "mapping"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "n"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_mapping"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "focus"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_focus"))}, - Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_mapping"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.ModuleNames")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.precision"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.Precision"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "arbitrary"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "arbitrary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "bits"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bits"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.Precision")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.util.qualifiedName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.QualifiedName"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.util.QualifiedName"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_moduleName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "local"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_local"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "moduleName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}, - Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_local"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.QualifiedName")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Validation.hs b/src/main/haskell/Hydra/Sources/Decode/Validation.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Validation.hs +++ /dev/null @@ -1,433 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.validation - -module Hydra.Sources.Decode.Validation where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.validation"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.validation"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.validation"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.validation.validationProfile"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.validation.ValidationProfile"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.validation.ValidationProfile"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "errorRules"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_errorRules"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "warningRules"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_warningRules"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "maxErrors"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_maxErrors"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "maxWarnings"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (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.extract.core.stripWithDecodingError")), - 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.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_maxWarnings"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "errorRules"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_errorRules"))}, - Core.Field { - Core.fieldName = (Core.Name "warningRules"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_warningRules"))}, - Core.Field { - Core.fieldName = (Core.Name "maxErrors"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_maxErrors"))}, - Core.Field { - Core.fieldName = (Core.Name "maxWarnings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_maxWarnings"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.validation.ValidationProfile")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.validation.validationResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "e"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (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 "e"))}))}))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg2"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (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.validation.ValidationResult")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "e"))}))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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 a record of type hydra.validation.ValidationResult"))}))))), - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (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.core.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "errors"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_errors"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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.core.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "warnings"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_warnings"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "errors"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_errors"))}, - Core.Field { - Core.fieldName = (Core.Name "warnings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_warnings"))}]}))))}))}))}))}))}))}))}]})), - 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.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.validation.ValidationResult")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Variants.hs b/src/main/haskell/Hydra/Sources/Decode/Variants.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Decode/Variants.hs +++ /dev/null @@ -1,1845 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.decode.variants - -module Hydra.Sources.Decode.Variants where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.decode.variants"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term decoders for hydra.variants"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.literalVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "binary"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "boolean"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "decimal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decimal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "float"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "integer"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "string"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.LiteralVariant")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.termVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.TermVariant"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotated"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "application"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "cases"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "either"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "inject"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "lambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "let"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "list"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "literal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "map"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "optional"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "pair"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "project"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "project"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "record"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "set"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "typeApplication"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "typeLambda"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unit"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unwrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unwrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "variable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "wrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.TermVariant")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.typeVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant"))}))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.either")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermCases (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.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (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.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingTypeScheme = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (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 "annotated"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "application"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "either"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "forall"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "function"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "list"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "literal"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "map"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "optional"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "pair"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "record"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "set"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "union"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "unit"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "variable"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "void"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - 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 "wrap"))}), - (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.eithers.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})), - Core.bindingTypeScheme = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})), - 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.TermVariable (Core.Name "hydra.lib.strings.cat")), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermLambda (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.TermVariable (Core.Name "stripped"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.TypeVariant")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Ast.hs b/src/main/haskell/Hydra/Sources/Encode/Ast.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Ast.hs +++ /dev/null @@ -1,1510 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.ast - -module Hydra.Sources.Encode.Ast where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.ast"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.ast"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.ast"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.associativity"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Associativity")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.ast.Associativity"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "none"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "left"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "right"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "both"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "both"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Associativity")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.blockStyle"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.BlockStyle")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.BlockStyle"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionFieldName = (Core.Name "indent")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "newlineBeforeContent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionFieldName = (Core.Name "newlineBeforeContent")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "newlineAfterContent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionFieldName = (Core.Name "newlineAfterContent")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.BlockStyle")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.bracketExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.BracketExpr")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.BracketExpr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.brackets")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionFieldName = (Core.Name "brackets")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "enclosed"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionFieldName = (Core.Name "enclosed")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "style"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.blockStyle")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionFieldName = (Core.Name "style")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.BracketExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.brackets"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Brackets")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Brackets"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "open"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionFieldName = (Core.Name "open")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "close"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionFieldName = (Core.Name "close")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Brackets")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.expr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Expr")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.ast.Expr"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "const"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "const"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "indent"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.indentedExpression")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "op"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.opExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "brackets"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.bracketExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "seq"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seq"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.seqExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Expr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.indentStyle"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.IndentStyle")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "allLines"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentStyle"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "allLines"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "subsequentLines"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentStyle"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subsequentLines"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.IndentStyle")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.indentedExpression"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.IndentedExpression")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentedExpression"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "style"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.indentStyle")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionFieldName = (Core.Name "style")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionFieldName = (Core.Name "expr")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.IndentedExpression")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.op"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Op")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Op"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "symbol"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionFieldName = (Core.Name "symbol")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "padding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.padding")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionFieldName = (Core.Name "padding")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "precedence"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.precedence")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionFieldName = (Core.Name "precedence")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "associativity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.associativity")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionFieldName = (Core.Name "associativity")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Op")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.opExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.OpExpr")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.OpExpr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.op")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionFieldName = (Core.Name "op")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lhs"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionFieldName = (Core.Name "lhs")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rhs"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionFieldName = (Core.Name "rhs")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.OpExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.padding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Padding")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Padding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.ws")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionFieldName = (Core.Name "left")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.ws")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionFieldName = (Core.Name "right")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Padding")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.precedence"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Precedence")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Precedence"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Precedence")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Precedence")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.seqExpr"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.SeqExpr")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.SeqExpr"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.op")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionFieldName = (Core.Name "op")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "elements"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.ast.expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionFieldName = (Core.Name "elements")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.SeqExpr")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.symbol"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Symbol")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Symbol"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Symbol")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Symbol")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.ws"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Ws")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.ast.Ws"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "none"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "space"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "space"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "break"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "break"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "breakAndIndent"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "breakAndIndent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "doubleBreak"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "doubleBreak"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Ws")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Coders.hs b/src/main/haskell/Hydra/Sources/Encode/Coders.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Coders.hs +++ /dev/null @@ -1,641 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.coders - -module Hydra.Sources.Encode.Coders where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.coders"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.coders"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.errors"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.graph"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.coders"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.caseConventions"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.CaseConventions")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CaseConventions"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "constant")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "directory"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "directory")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "enumValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "enumValue")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "field"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "file"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "file")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "termVariable")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"), - Core.projectionFieldName = (Core.Name "typeVariable")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.CaseConventions")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.coderDirection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "encode"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CoderDirection"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "encode"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decode"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CoderDirection"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decode"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.CoderDirection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.languageFeature"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.LanguageFeature")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.coders.LanguageFeature"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "partialApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "partialApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nestedCaseStatements"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedCaseStatements"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nestedPolymorphicLetBindings"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedPolymorphicLetBindings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.LanguageFeature")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.languageName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.coders.LanguageName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.LanguageName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.traversalOrder"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.TraversalOrder")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pre"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.TraversalOrder"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pre"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "post"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.TraversalOrder"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "post"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.TraversalOrder")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Core.hs b/src/main/haskell/Hydra/Sources/Encode/Core.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Core.hs +++ /dev/null @@ -1,4860 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.core - -module Hydra.Sources.Encode.Core where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.core"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.annotatedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.AnnotatedTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionFieldName = (Core.Name "annotation")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.AnnotatedTerm")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.annotatedType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.AnnotatedType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionFieldName = (Core.Name "annotation")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.AnnotatedType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.application"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Application")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Application"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionFieldName = (Core.Name "function")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "argument"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionFieldName = (Core.Name "argument")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Application")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.applicationType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.ApplicationType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionFieldName = (Core.Name "function")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "argument"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionFieldName = (Core.Name "argument")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.ApplicationType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.binding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Binding")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Binding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeScheme"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeScheme"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionFieldName = (Core.Name "typeScheme")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Binding")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.caseAlternative"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.CaseAlternative")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.CaseAlternative"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "handler"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"), - Core.projectionFieldName = (Core.Name "handler")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.CaseAlternative")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.caseStatement"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.CaseStatement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "default"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionFieldName = (Core.Name "default")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.caseAlternative"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionFieldName = (Core.Name "cases")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.CaseStatement")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.eitherType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.EitherType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.EitherType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionFieldName = (Core.Name "left")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionFieldName = (Core.Name "right")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.EitherType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.field"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Field")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Field"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Field")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.fieldType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FieldType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FieldType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FieldType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.floatType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FloatType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatType"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FloatType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.floatValue"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FloatValue")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FloatValue")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.forallType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.ForallType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.ForallType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionFieldName = (Core.Name "parameter")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.ForallType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.functionType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FunctionType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FunctionType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionFieldName = (Core.Name "domain")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "codomain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionFieldName = (Core.Name "codomain")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FunctionType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.injection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Injection")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Injection"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "field"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.field")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionFieldName = (Core.Name "field")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Injection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.integerType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.IntegerType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerType"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "bigint"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int8"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int16"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint8"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint16"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.IntegerType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.integerValue"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "bigint"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int8"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int16"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "int64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint8"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint16"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint32"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "uint64"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.IntegerValue")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.lambda"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Lambda")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Lambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionFieldName = (Core.Name "parameter")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionFieldName = (Core.Name "domain")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Lambda")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.let"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Let")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Let"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bindings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionFieldName = (Core.Name "bindings")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Let")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.literal"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Literal")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "binary"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decimal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.floatValue")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.integerValue")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Literal")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.literalType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.LiteralType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.LiteralType"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "binary"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.floatType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.integerType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.LiteralType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.mapType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.MapType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.MapType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keys"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionFieldName = (Core.Name "keys")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "values"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionFieldName = (Core.Name "values")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.MapType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.name"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Name")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.pairType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.PairType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.PairType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "first"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionFieldName = (Core.Name "first")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "second"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionFieldName = (Core.Name "second")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.PairType")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.projection"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Projection")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Projection"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionFieldName = (Core.Name "fieldName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Projection")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.record"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Record")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Record"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fields"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionFieldName = (Core.Name "fields")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Record")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.term"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotated"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.annotatedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "application"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.application")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "cases"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.caseStatement")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "either"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.injection")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.lambda")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "let"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.let")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "list"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literal")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "map"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optional"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pair"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "p"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "project"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.projection")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.record")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "set"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeApplicationTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeLambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeLambda")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unit"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unwrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "variable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.wrappedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Term")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.type"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Type"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotated"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.annotatedType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "application"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.applicationType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "either"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.eitherType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "forall"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.forallType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "function"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.functionType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "list"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "map"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.mapType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optional"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pair"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.pairType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.fieldType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "set"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "union"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.fieldType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unit"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "variable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "void"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Type")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeApplicationTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeApplicationTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeApplicationTerm")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeClassConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.TypeClassConstraint"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "simple"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeClassConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "simple"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeClassConstraint")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeLambda"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeLambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionFieldName = (Core.Name "parameter")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeLambda")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeScheme"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeScheme"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionFieldName = (Core.Name "variables")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constraints"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeVariableConstraints"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionFieldName = (Core.Name "constraints")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeScheme")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeVariableConstraints"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeVariableConstraints"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "classes"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeClassConstraint"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeVariableConstraints"), - Core.projectionFieldName = (Core.Name "classes")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeVariableConstraints")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.core.wrappedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.WrappedTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.WrappedTerm")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs +++ /dev/null @@ -1,1426 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.error.checking - -module Hydra.Sources.Encode.Error.Checking where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.checking"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.checking"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.checking"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.checkingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "incorrectUnification"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "incorrectUnification"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.incorrectUnificationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "notAForallType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAForallType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.notAForallTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "notAFunctionType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAFunctionType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.notAFunctionTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "other"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.otherCheckingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeArityMismatch"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArityMismatch"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.typeArityMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeMismatch"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.typeMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unboundTypeVariables"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unboundTypeVariables"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unboundTypeVariablesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.undefinedTermVariableCheckingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unequalTypes"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unequalTypes"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unequalTypesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unsupportedTermVariant"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupportedTermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unsupportedTermVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "untypedLambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedLambdaError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "untypedLetBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLetBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedLetBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "untypedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedTermVariableCheckingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.CheckingError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.incorrectUnificationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.IncorrectUnificationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.IncorrectUnificationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "substitution"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.typeSubst")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.projectionFieldName = (Core.Name "substitution")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.IncorrectUnificationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.notAForallTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAForallTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.NotAForallTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArguments"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionFieldName = (Core.Name "typeArguments")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.NotAForallTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.notAFunctionTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAFunctionTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.NotAFunctionTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.NotAFunctionTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.otherCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.OtherCheckingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.OtherCheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"), - Core.projectionFieldName = (Core.Name "message")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.OtherCheckingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.typeArityMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeArityMismatchError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.TypeArityMismatchError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedArity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionFieldName = (Core.Name "expectedArity")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualArity"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionFieldName = (Core.Name "actualArity")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArguments"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionFieldName = (Core.Name "typeArguments")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.TypeArityMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.typeMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeMismatchError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.TypeMismatchError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionFieldName = (Core.Name "expectedType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionFieldName = (Core.Name "actualType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.TypeMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unboundTypeVariablesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnboundTypeVariablesError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnboundTypeVariablesError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionFieldName = (Core.Name "variables")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnboundTypeVariablesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.undefinedTermVariableCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UndefinedTermVariableCheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UndefinedTermVariableCheckingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unequalTypesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnequalTypesError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnequalTypesError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "types"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionFieldName = (Core.Name "types")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnequalTypesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unsupportedTermVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnsupportedTermVariantError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnsupportedTermVariantError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.termVariant")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.projectionFieldName = (Core.Name "termVariant")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnsupportedTermVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedLambdaError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLambdaError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedLambdaError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedLambdaError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedLetBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLetBindingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedLetBindingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.binding")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.projectionFieldName = (Core.Name "binding")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedLetBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedTermVariableCheckingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedTermVariableCheckingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedTermVariableCheckingError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs +++ /dev/null @@ -1,3967 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.error.core - -module Hydra.Sources.Encode.Error.Core where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.core"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.core"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.core"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.constantConditionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.ConstantConditionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.ConstantConditionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionFieldName = (Core.Name "value")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.ConstantConditionError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateBindingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateFieldError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateRecordTypeFieldNamesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateRecordTypeFieldNamesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateUnionTypeFieldNamesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateUnionTypeFieldNamesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyCaseStatementError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyCaseStatementError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyCaseStatementError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyCaseStatementError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyLetBindingsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyLetBindingsError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyLetBindingsError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyLetBindingsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyRecordTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyRecordTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyRecordTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyRecordTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTermAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTermAnnotationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTermAnnotationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTermAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTypeAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeAnnotationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTypeAnnotationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTypeAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTypeNameInTermError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeNameInTermError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTypeNameInTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTypeNameInTermError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyUnionTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyUnionTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyUnionTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyUnionTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidForallParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidForallParameterNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidForallParameterNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidForallParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLambdaParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLambdaParameterNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLambdaParameterNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLambdaParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLetBindingNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLetBindingNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLetBindingNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLetBindingNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLiteralError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLiteralError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeMismatch"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLiteralError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.literalTypeMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLiteralError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTermError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTermError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "constantCondition"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constantCondition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.constantConditionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyCaseStatement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyCaseStatement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyCaseStatementError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyLetBindings"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyLetBindings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyLetBindingsError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyTermAnnotation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTermAnnotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTermAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyTypeNameInTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeNameInTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTypeNameInTermError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidLambdaParameterName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLambdaParameterName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLambdaParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidLetBindingName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLetBindingName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLetBindingNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidTypeLambdaParameterName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeLambdaParameterName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidTypeLambdaParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nestedTermAnnotation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTermAnnotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nestedTermAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "redundantWrapUnwrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "redundantWrapUnwrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.redundantWrapUnwrapError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "selfApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "selfApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.selfApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "termVariableShadowing"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariableShadowing"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.termVariableShadowingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeVariableShadowingInTypeLambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInTypeLambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.typeVariableShadowingInTypeLambdaError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInBindingType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInBindingType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInBindingTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInLambdaDomain"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInLambdaDomain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInLambdaDomainError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInTypeApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInTypeApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInTypeApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unknownPrimitiveName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unknownPrimitiveName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unknownPrimitiveNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unnecessaryIdentityApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unnecessaryIdentityApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unnecessaryIdentityApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "untypedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.untypedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTermError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateRecordTypeFieldNames"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateRecordTypeFieldNames"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateRecordTypeFieldNamesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateUnionTypeFieldNames"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateUnionTypeFieldNames"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateUnionTypeFieldNamesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyRecordType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyRecordType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyRecordTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyTypeAnnotation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeAnnotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTypeAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyUnionType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyUnionType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyUnionTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidForallParameterName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidForallParameterName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidForallParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidTypeSchemeVariableName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeSchemeVariableName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidTypeSchemeVariableNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nestedTypeAnnotation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTypeAnnotation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nestedTypeAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nonComparableMapKeyType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableMapKeyType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nonComparableMapKeyTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "nonComparableSetElementType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableSetElementType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nonComparableSetElementTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "singleVariantUnion"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "singleVariantUnion"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.singleVariantUnionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeVariableShadowingInForall"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInForall"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.typeVariableShadowingInForallError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTypeVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "voidInNonBottomPosition"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "voidInNonBottomPosition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.voidInNonBottomPositionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeLambdaParameterNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeLambdaParameterNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeLambdaParameterNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeSchemeVariableNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeSchemeVariableNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeSchemeVariableNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.literalTypeMismatchError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.LiteralTypeMismatchError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.LiteralTypeMismatchError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"), - Core.projectionFieldName = (Core.Name "expectedType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"), - Core.projectionFieldName = (Core.Name "actualType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.LiteralTypeMismatchError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nestedTermAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTermAnnotationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NestedTermAnnotationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NestedTermAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nestedTypeAnnotationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTypeAnnotationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NestedTypeAnnotationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NestedTypeAnnotationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nonComparableMapKeyTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableMapKeyTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NonComparableMapKeyTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keyType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionFieldName = (Core.Name "keyType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NonComparableMapKeyTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nonComparableSetElementTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableSetElementTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NonComparableSetElementTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "elementType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionFieldName = (Core.Name "elementType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NonComparableSetElementTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.redundantWrapUnwrapError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.RedundantWrapUnwrapError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.RedundantWrapUnwrapError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.RedundantWrapUnwrapError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.selfApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.SelfApplicationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.SelfApplicationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.SelfApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.singleVariantUnionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.SingleVariantUnionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.SingleVariantUnionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionFieldName = (Core.Name "fieldName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.SingleVariantUnionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.termVariableShadowingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TermVariableShadowingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TermVariableShadowingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TermVariableShadowingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.typeVariableShadowingInForallError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInForallError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TypeVariableShadowingInForallError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TypeVariableShadowingInForallError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.typeVariableShadowingInTypeLambdaError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedFieldError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionFieldName = (Core.Name "fieldName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTermVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTermVariableError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTermVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInBindingTypeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInLambdaDomainError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInTypeApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unexpectedTermVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnexpectedTermVariantError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.termVariant")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionFieldName = (Core.Name "expectedVariant")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionFieldName = (Core.Name "actualTerm")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnexpectedTermVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unexpectedTypeVariantError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnexpectedTypeVariantError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.typeVariant")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionFieldName = (Core.Name "expectedVariant")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionFieldName = (Core.Name "actualType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnexpectedTypeVariantError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unknownPrimitiveNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnknownPrimitiveNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnknownPrimitiveNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnknownPrimitiveNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unnecessaryIdentityApplicationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnnecessaryIdentityApplicationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnnecessaryIdentityApplicationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.untypedTermVariableError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UntypedTermVariableError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UntypedTermVariableError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.voidInNonBottomPositionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.VoidInNonBottomPositionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.VoidInNonBottomPositionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.projectionFieldName = (Core.Name "location")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.VoidInNonBottomPositionError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs +++ /dev/null @@ -1,1158 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.error.packaging - -module Hydra.Sources.Encode.Error.Packaging where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.packaging"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.packaging"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.packaging"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.util"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.packaging"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.conflictingModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingModuleNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.ConflictingModuleNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "first"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"), - Core.projectionFieldName = (Core.Name "first")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "second"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"), - Core.projectionFieldName = (Core.Name "second")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.ConflictingModuleNameError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.conflictingVariantNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingVariantNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.ConflictingVariantNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionFieldName = (Core.Name "typeName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variantName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionFieldName = (Core.Name "variantName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionFieldName = (Core.Name "conflictingName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.ConflictingVariantNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.definitionNotInModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DefinitionNotInModuleNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DefinitionNotInModuleNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.definitionsOutOfOrderError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DefinitionsOutOfOrderError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "precedingName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"), - Core.projectionFieldName = (Core.Name "precedingName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "followingName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"), - Core.projectionFieldName = (Core.Name "followingName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DefinitionsOutOfOrderError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.duplicateDefinitionNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DuplicateDefinitionNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DuplicateDefinitionNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.duplicateModuleNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateModuleNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DuplicateModuleNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DuplicateModuleNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidDefinitionNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidDefinitionNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidDefinitionNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"), - Core.projectionFieldName = (Core.Name "expectedConvention")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidDefinitionNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidModuleError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "conflictingVariantName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingVariantName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.conflictingVariantNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "definitionNotInModuleName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionNotInModuleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.definitionNotInModuleNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "definitionsOutOfOrder"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionsOutOfOrder"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.definitionsOutOfOrderError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateDefinitionName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateDefinitionName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.duplicateDefinitionNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidDefinitionName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidDefinitionName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidDefinitionNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidModuleNameConvention"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModuleNameConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidModuleNameConventionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "missingDocumentation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "missingDocumentation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.missingDocumentationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidModuleError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidModuleNameConventionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleNameConventionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidModuleNameConventionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidPackageError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "conflictingModuleName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingModuleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.conflictingModuleNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateModuleName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateModuleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.duplicateModuleNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidModule"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModule"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidModuleError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidPackageName"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidPackageName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidPackageNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidPackageError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidPackageNameError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageNameError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageNameError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "packageName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"), - Core.projectionFieldName = (Core.Name "packageName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidPackageNameError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.missingDocumentationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.MissingDocumentationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.MissingDocumentationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.MissingDocumentationError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Errors.hs b/src/main/haskell/Hydra/Sources/Encode/Errors.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Errors.hs +++ /dev/null @@ -1,1915 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.errors - -module Hydra.Sources.Encode.Errors where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.errors"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.errors"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.checking"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.errors"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.decodingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.DecodingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.DecodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.DecodingError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.emptyListError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = Core.TypeUnit, - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.EmptyListError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.error"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.Error")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.errors.Error"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "checking"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.checkingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decoding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decoding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.decodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "duplicateField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "extraction"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "extraction"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.extractionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inference"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.inferenceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "invalidLiteral"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLiteral"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLiteralError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "other"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "resolution"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "resolution"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.resolutionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "undefinedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "untypedTermVariable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.untypedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unexpectedTermVariant"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unexpectedTermVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unexpectedTypeVariant"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unexpectedTypeVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unification"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.Error")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.extractionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.ExtractionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.errors.ExtractionError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "emptyList"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyList"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.emptyListError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "multipleBindings"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleBindings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.multipleBindingsError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "multipleFields"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleFields"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.multipleFieldsError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "noMatchingField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noMatchingFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "noSuchBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "notEnoughCases"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEnoughCases"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.notEnoughCasesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unexpectedShape"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unexpectedShapeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.ExtractionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.inferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.InferenceError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.errors.InferenceError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "checking"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.checkingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "other"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherInferenceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unification"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationInferenceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.InferenceError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.multipleBindingsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.MultipleBindingsError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.MultipleBindingsError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.MultipleBindingsError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.MultipleBindingsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.multipleFieldsError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.MultipleFieldsError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.MultipleFieldsError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.MultipleFieldsError"), - Core.projectionFieldName = (Core.Name "fieldName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.MultipleFieldsError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noMatchingFieldError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoMatchingFieldError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"), - Core.projectionFieldName = (Core.Name "fieldName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoMatchingFieldError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noSuchBindingError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoSuchBindingError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchBindingError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoSuchBindingError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noSuchPrimitiveError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchPrimitiveError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoSuchPrimitiveError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoSuchPrimitiveError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.notEnoughCasesError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = Core.TypeUnit, - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NotEnoughCasesError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherInferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherInferenceError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherInferenceError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"), - Core.projectionFieldName = (Core.Name "message")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherInferenceError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherResolutionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherResolutionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherResolutionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherResolutionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.resolutionError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.ResolutionError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.errors.ResolutionError"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "noSuchBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "noSuchPrimitive"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchPrimitive"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchPrimitiveError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "noMatchingField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noMatchingFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "other"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherResolutionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unexpectedShape"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unexpectedShapeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.ResolutionError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unexpectedShapeError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnexpectedShapeError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"), - Core.projectionFieldName = (Core.Name "expected")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actual"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"), - Core.projectionFieldName = (Core.Name "actual")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnexpectedShapeError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unificationError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnificationError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "leftType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionFieldName = (Core.Name "leftType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rightType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionFieldName = (Core.Name "rightType")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionFieldName = (Core.Name "message")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnificationError")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unificationInferenceError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnificationInferenceError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnificationInferenceError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cause"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationError")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"), - Core.projectionFieldName = (Core.Name "cause")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnificationInferenceError")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs b/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs +++ /dev/null @@ -1,326 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.json.model - -module Hydra.Sources.Encode.Json.Model where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.json.model"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.json.model"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.json.model"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.json.model.value"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.json.model.Value")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.json.model.Value"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "array"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "array"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.json.model.value"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "null"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "null"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "number"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "number"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decimal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "object"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "p"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.json.model.value"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.json.model.Value")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Packaging.hs b/src/main/haskell/Hydra/Sources/Encode/Packaging.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Packaging.hs +++ /dev/null @@ -1,1701 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.packaging - -module Hydra.Sources.Encode.Packaging where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.packaging"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.packaging"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.packaging"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.definition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Definition")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.packaging.Definition"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "term"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.termDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "type"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.typeDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "primitive"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.primitiveDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Definition")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.definitionReference"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.DefinitionReference")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.packaging.DefinitionReference"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "type"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "term"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "primitive"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.DefinitionReference")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.entityMetadata"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityMetadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "comments"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"), - Core.projectionFieldName = (Core.Name "comments")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seeAlso"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityReference"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"), - Core.projectionFieldName = (Core.Name "seeAlso")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lifecycle"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.lifecycleInfo"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"), - Core.projectionFieldName = (Core.Name "lifecycle")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.EntityMetadata")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.entityReference"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.EntityReference")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.packaging.EntityReference"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "package"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "package"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "module"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "definition"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.definitionReference")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.EntityReference")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.lifecycleInfo"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.LifecycleInfo")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.LifecycleInfo"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "availableSince"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.version"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"), - Core.projectionFieldName = (Core.Name "availableSince")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "deprecatedSince"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.version"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"), - Core.projectionFieldName = (Core.Name "deprecatedSince")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.LifecycleInfo")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.module"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Module")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Module"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Module"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Module"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "dependencies"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleDependency"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Module"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitions"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.definition"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Module"), - Core.projectionFieldName = (Core.Name "definitions")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Module")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.moduleDependency"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleDependency")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.ModuleDependency"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"), - Core.projectionFieldName = (Core.Name "module")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "package"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"), - Core.projectionFieldName = (Core.Name "package")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.ModuleDependency")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.moduleName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.ModuleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.ModuleName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.ModuleName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.package"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Package")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Package"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "dependencies"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageDependency"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionFieldName = (Core.Name "dependencies")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "modules"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.module"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionFieldName = (Core.Name "modules")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Package")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.packageDependency"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PackageDependency")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PackageDependency"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "version"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.versionSpecifier")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"), - Core.projectionFieldName = (Core.Name "version")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PackageDependency")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.packageName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PackageName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.PackageName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PackageName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.primitiveDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PrimitiveDefinition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "signature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.termSignature")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "signature")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isPure"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "isPure")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isTotal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "isTotal")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "defaultImplementation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"), - Core.projectionFieldName = (Core.Name "defaultImplementation")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PrimitiveDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.termDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.TermDefinition")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.TermDefinition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "signature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.termSignature"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"), - Core.projectionFieldName = (Core.Name "signature")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.TermDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.typeDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.TypeDefinition")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.TypeDefinition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"), - Core.projectionFieldName = (Core.Name "metadata")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeScheme")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.TypeDefinition")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.version"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Version")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Version"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.Version")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Version")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.versionSpecifier"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.VersionSpecifier")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.packaging.VersionSpecifier"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "any"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.VersionSpecifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "any"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.VersionSpecifier")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Parsing.hs b/src/main/haskell/Hydra/Sources/Encode/Parsing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Parsing.hs +++ /dev/null @@ -1,317 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.parsing - -module Hydra.Sources.Encode.Parsing where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.parsing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.parsing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.parsing"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseError"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.parsing.ParseError")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseError"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionFieldName = (Core.Name "message")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "remainder"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionFieldName = (Core.Name "remainder")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseError")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseResult")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "success"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseResult"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "success"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseSuccess")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "failure"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseResult"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "failure"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseResult")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseSuccess"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseSuccess")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseSuccess"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "value"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "a")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionFieldName = (Core.Name "value")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "remainder"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionFieldName = (Core.Name "remainder")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseSuccess")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Paths.hs b/src/main/haskell/Hydra/Sources/Encode/Paths.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Paths.hs +++ /dev/null @@ -1,2226 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.paths - -module Hydra.Sources.Encode.Paths where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.paths"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.paths"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.paths"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermEdge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermEdge")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermEdge"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "source"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionFieldName = (Core.Name "source")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "target"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermEdge")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermGraph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermGraph")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermGraph"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nodes"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionFieldName = (Core.Name "nodes")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edges"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermEdge"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionFieldName = (Core.Name "edges")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermGraph")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermNode"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermNode")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermNode"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "label"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionFieldName = (Core.Name "label")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "id"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionFieldName = (Core.Name "id")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermNode")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermPath"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermPath"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermStep"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtermPath")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermPath")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermStep"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermStep")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotatedBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "applicationFunction"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "applicationArgument"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lambdaBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambdaBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unionCasesDefault"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesDefault"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unionCasesBranch"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesBranch"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "letBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "letBinding"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "listElement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "mapKey"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKey"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "mapValue"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValue"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optionalTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "productTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "productTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "recordField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "setElement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "sumTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sumTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeLambdaBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambdaBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeApplicationTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplicationTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "injectionTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "injectionTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrappedTerm"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermStep")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeEdge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeEdge")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeEdge"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "source"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionFieldName = (Core.Name "source")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypePath")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "target"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionFieldName = (Core.Name "target")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeEdge")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeGraph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeGraph")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeGraph"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nodes"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionFieldName = (Core.Name "nodes")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edges"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeEdge"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionFieldName = (Core.Name "edges")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeGraph")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeNode"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeNode")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeNode"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "label"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionFieldName = (Core.Name "label")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "id"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionFieldName = (Core.Name "id")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeNode")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypePath"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypePath")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypePath"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeStep"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtypePath")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypePath")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeStep"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeStep")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotatedBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "applicationFunction"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "applicationArgument"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "eitherLeft"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherLeft"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "eitherRight"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherRight"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "forallBody"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forallBody"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "functionDomain"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionDomain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "functionCodomain"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionCodomain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "listElement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "mapKeys"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKeys"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "mapValues"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValues"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optionalElement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalElement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pairFirst"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairFirst"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pairSecond"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairSecond"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "recordField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "setElement"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unionField"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionField"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrappedType"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeStep")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Query.hs b/src/main/haskell/Hydra/Sources/Encode/Query.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Query.hs +++ /dev/null @@ -1,1873 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.query - -module Hydra.Sources.Encode.Query where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.query"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.query"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.query"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.comparisonConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.ComparisonConstraint")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "equal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "notEqual"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEqual"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lessThan"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "greaterThan"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lessThanOrEqual"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThanOrEqual"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "greaterThanOrEqual"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThanOrEqual"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.ComparisonConstraint")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.edge"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Edge")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Edge"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "out"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionFieldName = (Core.Name "out")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "in"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionFieldName = (Core.Name "in")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Edge")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.graphPattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.GraphPattern")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.GraphPattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "graph"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionFieldName = (Core.Name "graph")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "patterns"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionFieldName = (Core.Name "patterns")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.GraphPattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.node"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Node")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.Node"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "term"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "variable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.variable")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wildcard"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wildcard"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Node")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.path"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Path")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.Path"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "step"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "step"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.step")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "regex"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "regex"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.regexSequence")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inverse"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inverse"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Path")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.pathEquation"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.PathEquation")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.PathEquation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionFieldName = (Core.Name "left")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionFieldName = (Core.Name "right")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.PathEquation")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.pattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Pattern")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.Pattern"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "triple"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "triple"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.triplePattern")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "negation"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "negation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "conjunction"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conjunction"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "disjunction"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "disjunction"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "graph"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "graph"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.graphPattern")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Pattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.patternImplication"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.PatternImplication")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.PatternImplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "antecedent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionFieldName = (Core.Name "antecedent")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "consequent"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionFieldName = (Core.Name "consequent")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.PatternImplication")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.query"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Query")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Query"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.variable"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionFieldName = (Core.Name "variables")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "patterns"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionFieldName = (Core.Name "patterns")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Query")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.range"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Range")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Range"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "min"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionFieldName = (Core.Name "min")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "max"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionFieldName = (Core.Name "max")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Range")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.regexQuantifier"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.RegexQuantifier")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "one"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "one"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "zeroOrOne"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrOne"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "zeroOrMore"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrMore"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "oneOrMore"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "oneOrMore"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "exactly"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "exactly"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "atLeast"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "atLeast"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "range"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "range"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.range")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.RegexQuantifier")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.regexSequence"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.RegexSequence")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexSequence"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionFieldName = (Core.Name "path")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "quantifier"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.regexQuantifier")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionFieldName = (Core.Name "quantifier")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.RegexSequence")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.step"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Step")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.query.Step"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "edge"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edge"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.edge")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "project"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.projection")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "compare"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "compare"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.comparisonConstraint")), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Step")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.triplePattern"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.TriplePattern")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.TriplePattern"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subject"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.node")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionFieldName = (Core.Name "subject")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "predicate"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionFieldName = (Core.Name "predicate")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.node")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionFieldName = (Core.Name "object")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.TriplePattern")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.query.variable"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Variable")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.query.Variable")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Variable")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Relational.hs b/src/main/haskell/Hydra/Sources/Encode/Relational.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Relational.hs +++ /dev/null @@ -1,721 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.relational - -module Hydra.Sources.Encode.Relational where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.relational"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.relational"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.relational"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.columnName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.ColumnName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ColumnName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.ColumnName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ColumnName")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.columnSchema"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "t"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.ColumnSchema")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ColumnSchema"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "t")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionFieldName = (Core.Name "domain")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ColumnSchema")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.foreignKey"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.ForeignKey")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ForeignKey"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "foreignRelation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionFieldName = (Core.Name "foreignRelation")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keys"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionFieldName = (Core.Name "keys")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ForeignKey")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.primaryKey"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.PrimaryKey")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.PrimaryKey"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.PrimaryKey")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.PrimaryKey")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relation"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relation")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Relation"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.row")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relation")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Relation")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.RelationName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.RelationName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.RelationName")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.RelationName")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationSchema"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "t"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.RelationSchema")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.RelationSchema"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "columns"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnSchema")), - Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionFieldName = (Core.Name "columns")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primaryKeys"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.primaryKey"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionFieldName = (Core.Name "primaryKeys")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "foreignKeys"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.foreignKey"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionFieldName = (Core.Name "foreignKeys")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.RelationSchema")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationship"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = [ - Core.TypeClassConstraintSimple (Core.Name "ordering")]}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relationship")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Relationship"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relationship")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Relationship")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.row"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Row")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Row"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Row")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Row")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Tabular.hs b/src/main/haskell/Hydra/Sources/Encode/Tabular.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Tabular.hs +++ /dev/null @@ -1,424 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.tabular - -module Hydra.Sources.Encode.Tabular where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.tabular"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.tabular"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.relational"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.tabular"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.columnType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.ColumnType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.ColumnType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.ColumnType")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.dataRow"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.DataRow")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.DataRow"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.DataRow")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.DataRow")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.headerRow"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.HeaderRow")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.HeaderRow"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.HeaderRow")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.HeaderRow")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.table"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "v"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.Table")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.Table"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "header"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.tabular.headerRow"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionFieldName = (Core.Name "header")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "data"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.tabular.dataRow")), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionFieldName = (Core.Name "data")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.Table")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.tableType"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.TableType")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.TableType"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "columns"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.tabular.columnType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionFieldName = (Core.Name "columns")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.TableType")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Testing.hs b/src/main/haskell/Hydra/Sources/Encode/Testing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Testing.hs +++ /dev/null @@ -1,77 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.testing - -module Hydra.Sources.Encode.Testing where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.testing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.testing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.testing"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.testing.tag"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.testing.Tag")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.testing.Tag"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.testing.Tag")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.testing.Tag")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Topology.hs b/src/main/haskell/Hydra/Sources/Encode/Topology.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Topology.hs +++ /dev/null @@ -1,358 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.topology - -module Hydra.Sources.Encode.Topology where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.topology"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.topology"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.topology"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.graph"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.topology.Vertex")), - Core.mapTypeValues = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.topology.Vertex")))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.Graph")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.tarjanState"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.topology.TarjanState")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.topology.TarjanState"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "counter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "counter")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indices"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "indices")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lowLinks"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "lowLinks")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "stack"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "stack")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "onStack"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "onStack")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sccs"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionFieldName = (Core.Name "sccs")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.TarjanState")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.vertex"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Literal")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.Vertex")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Typed.hs b/src/main/haskell/Hydra/Sources/Encode/Typed.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Typed.hs +++ /dev/null @@ -1,255 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.typed - -module Hydra.Sources.Encode.Typed where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.typed"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.typed"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typed"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedBinding"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedBinding")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedBinding"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typed.TypedBinding"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typed.typedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typed.TypedBinding"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedBinding")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedTerm"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedTerm"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedTerm")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedTermDefinition"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "a"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTermDefinition")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedTermDefinition"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typed.TypedTermDefinition"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typed.typedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typed.TypedTermDefinition"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedTermDefinition")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Typing.hs b/src/main/haskell/Hydra/Sources/Encode/Typing.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Typing.hs +++ /dev/null @@ -1,1173 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.typing - -module Hydra.Sources.Encode.Typing where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.typing"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.typing"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typing"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.functionStructure"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "env"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "env")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typing.FunctionStructure")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "env"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "env"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.FunctionStructure"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeParams"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "typeParams")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "params"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "params")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bindings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "bindings")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "body")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domains"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "domains")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "codomain"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "codomain")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "environment"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "env")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionFieldName = (Core.Name "environment")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.FunctionStructure")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.inferenceContext"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.InferenceContext"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "freshTypeVariableCount"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"), - Core.projectionFieldName = (Core.Name "freshTypeVariableCount")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "trace"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermStep"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"), - Core.projectionFieldName = (Core.Name "trace")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.InferenceContext")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.inferenceResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.InferenceResult")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.InferenceResult"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionFieldName = (Core.Name "term")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subst"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.typeSubst")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionFieldName = (Core.Name "subst")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "classConstraints"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeVariableConstraints"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionFieldName = (Core.Name "classConstraints")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "context"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.inferenceContext")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionFieldName = (Core.Name "context")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.InferenceResult")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.parameter"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.Parameter")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.Parameter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isLazy"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"), - Core.projectionFieldName = (Core.Name "isLazy")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.Parameter")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.result"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.Result")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.Result"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Result"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.Result"), - Core.projectionFieldName = (Core.Name "type")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.Result")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.termSignature"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TermSignature")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TermSignature"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeParameters"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.typeParameter"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"), - Core.projectionFieldName = (Core.Name "typeParameters")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameters"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.parameter"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"), - Core.projectionFieldName = (Core.Name "parameters")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "result"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.result")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"), - Core.projectionFieldName = (Core.Name "result")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TermSignature")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.termSubst"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TermSubst")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TermSubst"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TermSubst")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TermSubst")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeClass"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeClass")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeClass"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeClass"), - Core.projectionFieldName = (Core.Name "description")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeClass")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeConstraint"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeConstraint")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeConstraint"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionFieldName = (Core.Name "left")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionFieldName = (Core.Name "right")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "comment"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionFieldName = (Core.Name "comment")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeConstraint")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeParameter"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeParameter")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeParameter"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"), - Core.projectionFieldName = (Core.Name "name")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constraints"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeClassConstraint"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"), - Core.projectionFieldName = (Core.Name "constraints")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeParameter")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeSubst"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeSubst")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeSubst"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TypeSubst")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeSubst")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Util.hs b/src/main/haskell/Hydra/Sources/Encode/Util.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Util.hs +++ /dev/null @@ -1,703 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.util - -module Hydra.Sources.Encode.Util where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.util"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.util"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.packaging"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.caseConvention"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "camel"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "camel"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pascal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pascal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lowerSnake"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lowerSnake"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "upperSnake"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "upperSnake"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.CaseConvention")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.comparison"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.Comparison")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.util.Comparison"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lessThan"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "equalTo"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equalTo"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "greaterThan"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.Comparison")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.fileExtension"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.FileExtension")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.FileExtension"))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.util.FileExtension")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.FileExtension")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.moduleNames"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "n"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "n")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.ModuleNames")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "n"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "n"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.ModuleNames"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "focus"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "p"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "n"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"), - Core.projectionFieldName = (Core.Name "focus")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapping"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "n"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"), - Core.projectionFieldName = (Core.Name "mapping")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.ModuleNames")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.precision"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.Precision")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.util.Precision"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "arbitrary"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Precision"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "arbitrary"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "bits"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Precision"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bits"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.Precision")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.util.qualifiedName"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.QualifiedName")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.QualifiedName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "optional"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"), - Core.projectionFieldName = (Core.Name "moduleName")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "local"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"), - Core.projectionFieldName = (Core.Name "local")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.QualifiedName")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Validation.hs b/src/main/haskell/Hydra/Sources/Encode/Validation.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Validation.hs +++ /dev/null @@ -1,295 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.validation - -module Hydra.Sources.Encode.Validation where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.validation"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.validation"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.validation"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.validation.validationProfile"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.validation.ValidationProfile")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.validation.ValidationProfile"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "errorRules"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"), - Core.projectionFieldName = (Core.Name "errorRules")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "warningRules"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"), - Core.projectionFieldName = (Core.Name "warningRules")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maxErrors"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"), - Core.projectionFieldName = (Core.Name "maxErrors")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maxWarnings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"), - Core.projectionFieldName = (Core.Name "maxWarnings")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.validation.ValidationProfile")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.validation.validationResult"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [ - Typing.TypeParameter { - Typing.typeParameterName = (Core.Name "e"), - Typing.typeParameterConstraints = []}], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "e")), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Typing.parameterIsLazy = False}, - Typing.Parameter { - Typing.parameterName = (Core.Name "arg1"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.validation.ValidationResult")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "e"))})), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.validation.ValidationResult"))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList [ - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "errors"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"), - Core.projectionFieldName = (Core.Name "errors")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}), - (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "warnings"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermProject (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"), - Core.projectionFieldName = (Core.Name "warnings")})), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.validation.ValidationResult")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Variants.hs b/src/main/haskell/Hydra/Sources/Encode/Variants.hs deleted file mode 100644 --- a/src/main/haskell/Hydra/Sources/Encode/Variants.hs +++ /dev/null @@ -1,1812 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. --- | Source module for hydra.encode.variants - -module Hydra.Sources.Encode.Variants where -import qualified Hydra.Core as Core -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.Scientific as Sci -import qualified Data.Map as M -module_ :: Packaging.Module -module_ = - Packaging.Module { - Packaging.moduleName = (Packaging.ModuleName "hydra.encode.variants"), - Packaging.moduleMetadata = (Just (Packaging.EntityMetadata { - Packaging.entityMetadataDescription = (Just "Term encoders for hydra.variants"), - Packaging.entityMetadataComments = [], - Packaging.entityMetadataSeeAlso = [], - Packaging.entityMetadataLifecycle = Nothing})), - Packaging.moduleDependencies = [ - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"), - Packaging.moduleDependencyPackage = Nothing}, - Packaging.ModuleDependency { - Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.variants"), - Packaging.moduleDependencyPackage = Nothing}], - Packaging.moduleDefinitions = [ - Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.literalVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "binary"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "boolean"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "decimal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "float"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "integer"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "string"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.LiteralVariant")))]))}))}), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.termVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.TermVariant")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotated"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "application"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "cases"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "either"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "inject"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "lambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "let"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "list"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "map"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optional"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pair"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "project"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "set"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeApplication"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "typeLambda"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unit"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unwrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "variable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.TermVariant")))]))}))})), - (Packaging.DefinitionTerm (Packaging.TermDefinition { - Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.typeVariant"), - Packaging.termDefinitionMetadata = Nothing, - Packaging.termDefinitionSignature = (Just (Typing.TermSignature { - Typing.termSignatureTypeParameters = [], - Typing.termSignatureParameters = [ - Typing.Parameter { - Typing.parameterName = (Core.Name "arg0"), - Typing.parameterDescription = Nothing, - Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant")), - Typing.parameterIsLazy = False}], - Typing.termSignatureResult = Typing.Result { - Typing.resultDescription = Nothing, - Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})), - Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = [ - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "annotated"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "application"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "either"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "forall"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "function"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "list"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "literal"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "map"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "optional"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "pair"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "record"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "set"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "union"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "unit"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "variable"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "void"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}, - Core.CaseAlternative { - Core.caseAlternativeName = (Core.Name "wrap"), - Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inject"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermInject (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})), - Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [ - ( - Core.TermVariable (Core.Name "description"), - (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.TypeVariant")))]))}))}))]}