hydra-kernel 0.16.0 → 0.16.1

raw patch · 111 files changed

+8336/−68200 lines, 111 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +198/−0
• NOTICE +3/−0
• hydra-kernel.cabal +42/−43
• src/main/haskell/Hydra/Checking.hs +26/−12
• src/main/haskell/Hydra/Codegen.hs +2/−1
• src/main/haskell/Hydra/Decode/Error/Packaging.hs +185/−0
• src/main/haskell/Hydra/Decode/Parsing.hs +2/−2
• src/main/haskell/Hydra/Decode/Relational.hs +5/−5
• src/main/haskell/Hydra/Decode/Tabular.hs +2/−2
• src/main/haskell/Hydra/Decode/Topology.hs +1/−1
• src/main/haskell/Hydra/Decode/Typed.hs +3/−3
• src/main/haskell/Hydra/Decode/Typing.hs +1/−1
• src/main/haskell/Hydra/Decode/Util.hs +1/−1
• src/main/haskell/Hydra/Decode/Validation.hs +51/−0
• src/main/haskell/Hydra/Decode/Yaml/Model.hs +92/−0
• src/main/haskell/Hydra/Decoding.hs +2006/−1431
• src/main/haskell/Hydra/Dsl/Annotations.hs +85/−0
• src/main/haskell/Hydra/Dsl/AsTerm.hs +52/−0
• src/main/haskell/Hydra/Dsl/AsType.hs +25/−0
• src/main/haskell/Hydra/Dsl/Bootstrap.hs +76/−0
• src/main/haskell/Hydra/Dsl/Deep/Lib/Math.hs +131/−0
• src/main/haskell/Hydra/Dsl/Graph.hs +3/−3
• src/main/haskell/Hydra/Dsl/Libraries.hs +422/−0
• src/main/haskell/Hydra/Dsl/LiteralTypes.hs +86/−0
• src/main/haskell/Hydra/Dsl/Meta/Base.hs +28/−0
• src/main/haskell/Hydra/Dsl/Meta/Core.hs +56/−0
• src/main/haskell/Hydra/Dsl/Meta/DeepCore.hs +172/−0
• src/main/haskell/Hydra/Dsl/Meta/Graph.hs +38/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Chars.hs +34/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Eithers.hs +71/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Equality.hs +52/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Lists.hs +161/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Literals.hs +234/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Logic.hs +40/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Maps.hs +95/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Math.hs +202/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Optionals.hs +63/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Pairs.hs +22/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Regex.hs +34/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Sets.hs +71/−0
• src/main/haskell/Hydra/Dsl/Meta/Lib/Strings.hs +68/−0
• src/main/haskell/Hydra/Dsl/Meta/Literals.hs +80/−0
• src/main/haskell/Hydra/Dsl/Meta/Phantoms.hs +487/−0
• src/main/haskell/Hydra/Dsl/Meta/Tabular.hs +14/−0
• src/main/haskell/Hydra/Dsl/Meta/Terms.hs +528/−0
• src/main/haskell/Hydra/Dsl/Meta/Testing.hs +536/−0
• src/main/haskell/Hydra/Dsl/Meta/Types.hs +298/−0
• src/main/haskell/Hydra/Dsl/Meta/Variants.hs +68/−0
• src/main/haskell/Hydra/Dsl/Prims.hs +435/−0
• src/main/haskell/Hydra/Dsl/Terms.hs +20/−3
• src/main/haskell/Hydra/Dsl/Tests.hs +29/−0
• src/main/haskell/Hydra/Dsl/Types.hs +266/−0
• src/main/haskell/Hydra/Encode/Error/Checking.hs +1/−1
• src/main/haskell/Hydra/Encode/Error/Packaging.hs +197/−0
• src/main/haskell/Hydra/Encode/Errors.hs +2/−2
• src/main/haskell/Hydra/Encode/Parsing.hs +2/−2
• src/main/haskell/Hydra/Encode/Relational.hs +5/−5
• src/main/haskell/Hydra/Encode/Tabular.hs +2/−2
• src/main/haskell/Hydra/Encode/Topology.hs +1/−1
• src/main/haskell/Hydra/Encode/Typed.hs +3/−3
• src/main/haskell/Hydra/Encode/Typing.hs +1/−1
• src/main/haskell/Hydra/Encode/Util.hs +1/−1
• src/main/haskell/Hydra/Encode/Validation.hs +42/−0
• src/main/haskell/Hydra/Encode/Yaml/Model.hs +64/−0
• src/main/haskell/Hydra/Encoding.hs +76/−30
• src/main/haskell/Hydra/Graph.hs +2/−2
• src/main/haskell/Hydra/Json/Bootstrap.hs +6/−8
• src/main/haskell/Hydra/Lib/Lists.hs +227/−6
• src/main/haskell/Hydra/Reduction.hs +2/−2
• src/main/haskell/Hydra/Sources/Decode/Ast.hs +0/−2441
• src/main/haskell/Hydra/Sources/Decode/Coders.hs +0/−1016
• src/main/haskell/Hydra/Sources/Decode/Core.hs +0/−6527
• src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs +0/−2013
• src/main/haskell/Hydra/Sources/Decode/Error/Core.hs +0/−5438
• src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs +0/−1632
• src/main/haskell/Hydra/Sources/Decode/Errors.hs +0/−2759
• src/main/haskell/Hydra/Sources/Decode/Json/Model.hs +0/−503
• src/main/haskell/Hydra/Sources/Decode/Packaging.hs +0/−2563
• src/main/haskell/Hydra/Sources/Decode/Parsing.hs +0/−599
• src/main/haskell/Hydra/Sources/Decode/Paths.hs +0/−2771
• src/main/haskell/Hydra/Sources/Decode/Query.hs +0/−2719
• src/main/haskell/Hydra/Sources/Decode/Relational.hs +0/−1087
• src/main/haskell/Hydra/Sources/Decode/Tabular.hs +0/−614
• src/main/haskell/Hydra/Sources/Decode/Testing.hs +0/−164
• src/main/haskell/Hydra/Sources/Decode/Topology.hs +0/−517
• src/main/haskell/Hydra/Sources/Decode/Typed.hs +0/−391
• src/main/haskell/Hydra/Sources/Decode/Typing.hs +0/−1709
• src/main/haskell/Hydra/Sources/Decode/Util.hs +0/−1147
• src/main/haskell/Hydra/Sources/Decode/Validation.hs +0/−433
• src/main/haskell/Hydra/Sources/Decode/Variants.hs +0/−1845
• src/main/haskell/Hydra/Sources/Encode/Ast.hs +0/−1510
• src/main/haskell/Hydra/Sources/Encode/Coders.hs +0/−641
• src/main/haskell/Hydra/Sources/Encode/Core.hs +0/−4860
• src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs +0/−1426
• src/main/haskell/Hydra/Sources/Encode/Error/Core.hs +0/−3967
• src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs +0/−1158
• src/main/haskell/Hydra/Sources/Encode/Errors.hs +0/−1915
• src/main/haskell/Hydra/Sources/Encode/Json/Model.hs +0/−326
• src/main/haskell/Hydra/Sources/Encode/Packaging.hs +0/−1701
• src/main/haskell/Hydra/Sources/Encode/Parsing.hs +0/−317
• src/main/haskell/Hydra/Sources/Encode/Paths.hs +0/−2226
• src/main/haskell/Hydra/Sources/Encode/Query.hs +0/−1873
• src/main/haskell/Hydra/Sources/Encode/Relational.hs +0/−721
• src/main/haskell/Hydra/Sources/Encode/Tabular.hs +0/−424
• src/main/haskell/Hydra/Sources/Encode/Testing.hs +0/−77
• src/main/haskell/Hydra/Sources/Encode/Topology.hs +0/−358
• src/main/haskell/Hydra/Sources/Encode/Typed.hs +0/−255
• src/main/haskell/Hydra/Sources/Encode/Typing.hs +0/−1173
• src/main/haskell/Hydra/Sources/Encode/Util.hs +0/−703
• src/main/haskell/Hydra/Sources/Encode/Validation.hs +0/−295
• src/main/haskell/Hydra/Sources/Encode/Variants.hs +0/−1812

@@ -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/<lang>/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_<field>` 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<v>` 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

@@ -0,0 +1,3 @@+Hydra+Copyright 2021-2026 The Hydra authors+https://github.com/CategoricalData/hydra

@@ -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

@@ -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)

@@ -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

@@ -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)

@@ -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 ->

@@ -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))

@@ -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 ->

@@ -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

@@ -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 ->

@@ -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 ->

@@ -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 ->

@@ -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)

@@ -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)

@@ -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<v>) 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<v> 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<v>) 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<v>) 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))})

@@ -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

@@ -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

@@ -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)

@@ -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)

@@ -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)

@@ -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"),

@@ -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 ".<local>" segment dropped+    firstName = unName $ primitiveDefinitionName $ primitiveDefinition $ head prims+    ns = ModuleName $ reverse $ L.drop 1 $ L.dropWhile (/= '.') $ reverse firstName

@@ -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

@@ -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

@@ -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)

@@ -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

@@ -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+

@@ -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

@@ -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

@@ -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)

@@ -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

@@ -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

@@ -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

@@ -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